From 48dea2ea0ce93b80484abac6875da4fdf5a20ce7 Mon Sep 17 00:00:00 2001 From: "Chris St. Pierre" Date: Thu, 8 Aug 2013 15:35:23 -0400 Subject: testsuite: fixed unit tests for server plugins --- .../Testlib/TestClient/TestTools/TestPOSIXUsers.py | 5 +- .../Testlib/TestClient/TestTools/Test_init.py | 6 +- testsuite/Testsrc/Testlib/TestLogger.py | 4 +- .../Testlib/TestServer/TestPlugin/Testbase.py | 6 +- .../Testlib/TestServer/TestPlugin/Testhelpers.py | 60 ++++++-- .../TestCfg/TestCfgAuthorizedKeysGenerator.py | 28 +--- .../TestPlugins/TestCfg/TestCfgCheetahGenerator.py | 14 +- .../TestCfg/TestCfgEncryptedGenerator.py | 2 +- .../TestCfg/TestCfgEncryptedGenshiGenerator.py | 2 +- .../TestPlugins/TestCfg/TestCfgGenshiGenerator.py | 47 +++--- .../TestPlugins/TestCfg/TestCfgInfoXML.py | 4 + .../TestCfg/TestCfgPrivateKeyCreator.py | 129 +++++----------- .../TestServer/TestPlugins/TestCfg/Test_init.py | 100 +++++-------- .../Testlib/TestServer/TestPlugins/TestMetadata.py | 29 ++-- .../Testlib/TestServer/TestPlugins/TestProbes.py | 164 +++++++++++---------- .../TestServer/TestPlugins/TestProperties.py | 49 ++---- .../Testlib/TestServer/TestPlugins/TestRules.py | 12 +- 17 files changed, 299 insertions(+), 362 deletions(-) (limited to 'testsuite/Testsrc') diff --git a/testsuite/Testsrc/Testlib/TestClient/TestTools/TestPOSIXUsers.py b/testsuite/Testsrc/Testlib/TestClient/TestTools/TestPOSIXUsers.py index 3d2e762ff..d9d8a26c6 100644 --- a/testsuite/Testsrc/Testlib/TestClient/TestTools/TestPOSIXUsers.py +++ b/testsuite/Testsrc/Testlib/TestClient/TestTools/TestPOSIXUsers.py @@ -24,11 +24,14 @@ from TestTools.Test_init import TestTool class TestPOSIXUsers(TestTool): test_obj = POSIXUsers - def get_obj(self, config=None): + def setUp(self): + TestTool.setUp(self) set_setup_default('uid_whitelist') set_setup_default('uid_blacklist') set_setup_default('gid_whitelist') set_setup_default('gid_blacklist') + + def get_obj(self, config=None): return TestTool.get_obj(self, config) @patch("pwd.getpwall") diff --git a/testsuite/Testsrc/Testlib/TestClient/TestTools/Test_init.py b/testsuite/Testsrc/Testlib/TestClient/TestTools/Test_init.py index cbf8e4911..1bf073f81 100644 --- a/testsuite/Testsrc/Testlib/TestClient/TestTools/Test_init.py +++ b/testsuite/Testsrc/Testlib/TestClient/TestTools/Test_init.py @@ -21,11 +21,13 @@ from common import * class TestTool(Bcfg2TestCase): test_obj = Tool + def setUp(self): + set_setup_default('command_timeout') + set_setup_default('interactive', False) + def get_obj(self, config=None): if config is None: config = lxml.etree.Element("Configuration") - set_setup_default('command_timeout') - set_setup_default('interactive', False) execs = self.test_obj.__execs__ self.test_obj.__execs__ = [] diff --git a/testsuite/Testsrc/Testlib/TestLogger.py b/testsuite/Testsrc/Testlib/TestLogger.py index 0da39deb2..1baea2f35 100644 --- a/testsuite/Testsrc/Testlib/TestLogger.py +++ b/testsuite/Testsrc/Testlib/TestLogger.py @@ -19,8 +19,10 @@ from common import * class TestDebuggable(Bcfg2TestCase): test_obj = Debuggable - def get_obj(self): + def setUp(self): set_setup_default('debug', False) + + def get_obj(self): return self.test_obj() def test__init(self): diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugin/Testbase.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugin/Testbase.py index db126b3a1..9b55b3ae8 100644 --- a/testsuite/Testsrc/Testlib/TestServer/TestPlugin/Testbase.py +++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugin/Testbase.py @@ -19,10 +19,14 @@ from TestLogger import TestDebuggable class TestPlugin(TestDebuggable): test_obj = Plugin + def setUp(self): + TestDebuggable.setUp(self) + set_setup_default("filemonitor", MagicMock()) + def get_obj(self, core=None): if core is None: core = Mock() - 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 3439d475f..7006e29e3 100644 --- a/testsuite/Testsrc/Testlib/TestServer/TestPlugin/Testhelpers.py +++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugin/Testhelpers.py @@ -51,22 +51,28 @@ class TestFunctions(Bcfg2TestCase): class TestDatabaseBacked(TestPlugin): test_obj = DatabaseBacked + def setUp(self): + TestPlugin.setUp(self) + set_setup_default("%s_db" % self.test_obj.__name__.lower(), False) + @skipUnless(HAS_DJANGO, "Django not found") def test__use_db(self): - db = self.get_obj() + core = Mock() + db = self.get_obj(core=core) + attr = "%s_db" % self.test_obj.__name__.lower() - Bcfg2.Options.setup.databasebacked_db = True + db.core.database_available = True + setattr(Bcfg2.Options.setup, attr, True) self.assertTrue(db._use_db) - Bcfg2.Options.setup.databasebacked_db = False + setattr(Bcfg2.Options.setup, attr, False) self.assertFalse(db._use_db) - Bcfg2.Server.Plugin.helpers.HAS_DJANGO = False + db.core.database_available = False self.assertFalse(db._use_db) - Bcfg2.Options.setup.databasebacked_db = False + setattr(Bcfg2.Options.setup, attr, True) self.assertFalse(db._use_db) - Bcfg2.Server.Plugin.helpers.HAS_DJANGO = True class TestPluginDatabaseModel(Bcfg2TestCase): @@ -74,14 +80,17 @@ class TestPluginDatabaseModel(Bcfg2TestCase): pass -class TestFileBacked(Bcfg2TestCase): +class TestFileBacked(TestDebuggable): test_obj = FileBacked path = os.path.join(datastore, "test") + def setUp(self): + TestDebuggable.setUp(self) + set_setup_default("filemonitor", MagicMock()) + 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) @@ -110,7 +119,7 @@ class TestFileBacked(Bcfg2TestCase): self.assertFalse(fb.Index.called) -class TestDirectoryBacked(Bcfg2TestCase): +class TestDirectoryBacked(TestDebuggable): test_obj = DirectoryBacked testpaths = {1: '', 2: '/foo', @@ -124,6 +133,10 @@ class TestDirectoryBacked(Bcfg2TestCase): badevents = [] # DirectoryBacked handles all files, so there's no # such thing as a bad event + def setUp(self): + TestDebuggable.setUp(self) + set_setup_default("filemonitor", MagicMock()) + def test_child_interface(self): """ ensure that the child object has the correct interface """ self.assertTrue(hasattr(self.test_obj.__child__, "HandleEvent")) @@ -133,7 +146,6 @@ 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()) @@ -378,11 +390,13 @@ class TestXMLFileBacked(TestFileBacked): should_monitor = None path = os.path.join(datastore, "test", "test1.xml") + def setUp(self): + TestFileBacked.setUp(self) + set_setup_default("encoding", 'utf-8') + 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()) @@ -1158,6 +1172,11 @@ class TestXMLDirectoryBacked(TestDirectoryBacked): class TestPrioDir(TestPlugin, TestGenerator, TestXMLDirectoryBacked): test_obj = PrioDir + def setUp(self): + TestPlugin.setUp(self) + TestGenerator.setUp(self) + TestXMLDirectoryBacked.setUp(self) + def get_obj(self, core=None): if core is None: core = Mock() @@ -1331,10 +1350,14 @@ class TestSpecificity(Bcfg2TestCase): self.assertGreaterEqual(specs[j], specs[i]) -class TestSpecificData(Bcfg2TestCase): +class TestSpecificData(TestDebuggable): test_obj = SpecificData path = os.path.join(datastore, "test.txt") + def setUp(self): + TestDebuggable.setUp(self) + set_setup_default("encoding", "utf-8") + def get_obj(self, name=None, specific=None): if name is None: name = self.path @@ -1382,7 +1405,8 @@ 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()): + def setUp(self): + TestDebuggable.setUp(self) set_setup_default("default_owner") set_setup_default("default_group") set_setup_default("default_mode") @@ -1390,6 +1414,8 @@ class TestEntrySet(TestDebuggable): set_setup_default("default_important", False) set_setup_default("default_paranoid", False) set_setup_default("default_sensitive", False) + + def get_obj(self, basename="test", path=datastore, entry_type=MagicMock()): return self.test_obj(basename, path, entry_type) def test__init(self): @@ -1742,10 +1768,14 @@ class TestEntrySet(TestDebuggable): class TestGroupSpool(TestPlugin, TestGenerator): test_obj = GroupSpool + def setUp(self): + TestPlugin.setUp(self) + TestGenerator.setUp(self) + set_setup_default("encoding", "utf-8") + def get_obj(self, core=None): if core is None: core = MagicMock() - set_setup_default("encoding", "utf-8") @patch("%s.%s.AddDirectoryMonitor" % (self.test_obj.__module__, self.test_obj.__name__), diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgAuthorizedKeysGenerator.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgAuthorizedKeysGenerator.py index b77d52033..e5cef8fa2 100644 --- a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgAuthorizedKeysGenerator.py +++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgAuthorizedKeysGenerator.py @@ -23,6 +23,10 @@ class TestCfgAuthorizedKeysGenerator(TestCfgGenerator, TestStructFile): test_obj = CfgAuthorizedKeysGenerator should_monitor = False + def setUp(self): + TestCfgGenerator.setUp(self) + TestStructFile.setUp(self) + def get_obj(self, name=None, core=None, fam=None): if name is None: name = self.path @@ -40,31 +44,9 @@ class TestCfgAuthorizedKeysGenerator(TestCfgGenerator, TestStructFile): mock_HandleEvent.assert_called_with(akg, evt) mock_handle_event.assert_called_with(akg, evt) - def test_category(self): - akg = self.get_obj() - akg.setup = Mock() - akg.setup.cfp.has_section.return_value = False - akg.setup.cfp.has_option.return_value = False - - self.assertIsNone(akg.category) - akg.setup.cfp.has_section.assert_called_with("sshkeys") - - akg.setup.reset_mock() - akg.setup.cfp.has_section.return_value = True - self.assertIsNone(akg.category) - akg.setup.cfp.has_section.assert_called_with("sshkeys") - akg.setup.cfp.has_option.assert_called_with("sshkeys", "category") - - akg.setup.reset_mock() - akg.setup.cfp.has_option.return_value = True - self.assertEqual(akg.category, akg.setup.cfp.get.return_value) - akg.setup.cfp.has_section.assert_called_with("sshkeys") - akg.setup.cfp.has_option.assert_called_with("sshkeys", "category") - akg.setup.cfp.get.assert_called_with("sshkeys", "category") - @patch("Bcfg2.Server.Plugins.Cfg.CfgAuthorizedKeysGenerator.ClientMetadata") - @patch("Bcfg2.Server.Plugins.Cfg.CfgAuthorizedKeysGenerator.CfgAuthorizedKeysGenerator.category", "category") def test_get_data(self, mock_ClientMetadata): + Bcfg2.Options.setup.sshkeys_category = "category" akg = self.get_obj() akg.XMLMatch = Mock() diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgCheetahGenerator.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgCheetahGenerator.py index 31227329c..e1ffa7272 100644 --- a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgCheetahGenerator.py +++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgCheetahGenerator.py @@ -23,25 +23,25 @@ if HAS_CHEETAH or can_skip: @skipUnless(HAS_CHEETAH, "Cheetah libraries not found, skipping") def setUp(self): - pass + TestCfgGenerator.setUp(self) + set_setup_default("repository", datastore) @patch("Bcfg2.Server.Plugins.Cfg.CfgCheetahGenerator.Template") def test_get_data(self, mock_Template): - ccg = self.get_obj(encoding='UTF-8') + ccg = self.get_obj() ccg.data = "data" entry = lxml.etree.Element("Path", name="/test.txt") metadata = Mock() - ccg.setup = MagicMock() self.assertEqual(ccg.get_data(entry, metadata), mock_Template.return_value.respond.return_value) - ccg.setup.__getitem__.assert_called_with("repo") - mock_Template.assert_called_with("data".decode(ccg.encoding), - compilerSettings=ccg.settings) + mock_Template.assert_called_with( + "data".decode(Bcfg2.Options.setup.encoding), + compilerSettings=ccg.settings) tmpl = mock_Template.return_value tmpl.respond.assert_called_with() self.assertEqual(tmpl.metadata, metadata) self.assertEqual(tmpl.name, entry.get("name")) self.assertEqual(tmpl.path, entry.get("name")) self.assertEqual(tmpl.source_path, ccg.name) - self.assertEqual(tmpl.repo, ccg.setup.__getitem__.return_value) + self.assertEqual(tmpl.repo, datastore) diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgEncryptedGenerator.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgEncryptedGenerator.py index f8e9b1990..5409cf863 100644 --- a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgEncryptedGenerator.py +++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgEncryptedGenerator.py @@ -24,7 +24,7 @@ if can_skip or HAS_CRYPTO: @skipUnless(HAS_CRYPTO, "Encryption libraries not found, skipping") def setUp(self): - pass + TestCfgGenerator.setUp(self) @patchIf(HAS_CRYPTO, "Bcfg2.Server.Plugins.Cfg.CfgEncryptedGenerator.bruteforce_decrypt") diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgEncryptedGenshiGenerator.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgEncryptedGenshiGenerator.py index 330779c99..25d2fb83b 100644 --- a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgEncryptedGenshiGenerator.py +++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgEncryptedGenshiGenerator.py @@ -24,4 +24,4 @@ if can_skip or HAS_CRYPTO: @skipUnless(HAS_CRYPTO, "Encryption libraries not found, skipping") def setUp(self): - pass + TestCfgGenshiGenerator.setUp(self) diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgGenshiGenerator.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgGenshiGenerator.py index b73670fb7..9b6e7fe88 100644 --- a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgGenshiGenerator.py +++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgGenshiGenerator.py @@ -22,6 +22,10 @@ from TestServer.TestPlugins.TestCfg.Test_init import TestCfgGenerator class TestCfgGenshiGenerator(TestCfgGenerator): test_obj = CfgGenshiGenerator + def setUp(self): + TestCfgGenerator.setUp(self) + set_setup_default("repository", datastore) + def test__init(self): TestCfgGenerator.test__init(self) cgg = self.get_obj() @@ -30,7 +34,6 @@ class TestCfgGenshiGenerator(TestCfgGenerator): def test_get_data(self): cgg = self.get_obj() cgg._handle_genshi_exception = Mock() - cgg.setup = MagicMock() cgg.template = Mock() fltr = Mock() cgg.template.generate.return_value = fltr @@ -39,26 +42,25 @@ class TestCfgGenshiGenerator(TestCfgGenerator): entry = lxml.etree.Element("Path", name="/test.txt") metadata = Mock() - def reset(): cgg.template.reset_mock() cgg._handle_genshi_exception.reset_mock() - cgg.setup.reset_mock() template_vars = dict( name=entry.get("name"), metadata=metadata, path=cgg.name, source_path=cgg.name, - repo=cgg.setup.__getitem__.return_value) + repo=datastore) self.assertEqual(cgg.get_data(entry, metadata), stream.render.return_value) cgg.template.generate.assert_called_with(**template_vars) - cgg.setup.__getitem__.assert_called_with("repo") fltr.filter.assert_called_with(removecomment) - stream.render.assert_called_with("text", encoding=cgg.encoding, - strip_whitespace=False) + stream.render.assert_called_with( + "text", + encoding=Bcfg2.Options.setup.encoding, + strip_whitespace=False) reset() def render(fmt, **kwargs): @@ -68,21 +70,22 @@ class TestCfgGenshiGenerator(TestCfgGenerator): self.assertEqual(cgg.get_data(entry, metadata), stream.render.return_value) cgg.template.generate.assert_called_with(**template_vars) - cgg.setup.__getitem__.assert_called_with("repo") fltr.filter.assert_called_with(removecomment) self.assertEqual(stream.render.call_args_list, - [call("text", encoding=cgg.encoding, - strip_whitespace=False), - call("text", encoding=cgg.encoding)]) + [call("text", + encoding=Bcfg2.Options.setup.encoding, + strip_whitespace=False), + call("text", + encoding=Bcfg2.Options.setup.encoding)]) reset() stream.render.side_effect = UndefinedError("test") self.assertRaises(UndefinedError, cgg.get_data, entry, metadata) cgg.template.generate.assert_called_with(**template_vars) - cgg.setup.__getitem__.assert_called_with("repo") fltr.filter.assert_called_with(removecomment) - stream.render.assert_called_with("text", encoding=cgg.encoding, + stream.render.assert_called_with("text", + encoding=Bcfg2.Options.setup.encoding, strip_whitespace=False) reset() @@ -91,9 +94,9 @@ class TestCfgGenshiGenerator(TestCfgGenerator): self.assertRaises(ValueError, cgg.get_data, entry, metadata) cgg.template.generate.assert_called_with(**template_vars) - cgg.setup.__getitem__.assert_called_with("repo") fltr.filter.assert_called_with(removecomment) - stream.render.assert_called_with("text", encoding=cgg.encoding, + stream.render.assert_called_with("text", + encoding=Bcfg2.Options.setup.encoding, strip_whitespace=False) self.assertTrue(cgg._handle_genshi_exception.called) @@ -102,14 +105,16 @@ class TestCfgGenshiGenerator(TestCfgGenerator): cgg.loader = Mock() event = Mock() cgg.handle_event(event) - cgg.loader.load.assert_called_with(cgg.name, - cls=NewTextTemplate, - encoding=cgg.encoding) + cgg.loader.load.assert_called_with( + cgg.name, + cls=NewTextTemplate, + encoding=Bcfg2.Options.setup.encoding) cgg.loader.reset_mock() cgg.loader.load.side_effect = OSError self.assertRaises(PluginExecutionError, cgg.handle_event, event) - cgg.loader.load.assert_called_with(cgg.name, - cls=NewTextTemplate, - encoding=cgg.encoding) + cgg.loader.load.assert_called_with( + cgg.name, + cls=NewTextTemplate, + encoding=Bcfg2.Options.setup.encoding) diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgInfoXML.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgInfoXML.py index 7e7cb5e3c..349da2213 100644 --- a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgInfoXML.py +++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgInfoXML.py @@ -21,6 +21,10 @@ from TestServer.TestPlugins.TestCfg.Test_init import TestCfgInfo class TestCfgInfoXML(TestCfgInfo): test_obj = CfgInfoXML + def setUp(self): + TestCfgInfo.setUp(self) + set_setup_default("filemonitor", MagicMock()) + def test__init(self): TestCfgInfo.test__init(self) ci = self.get_obj() diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgPrivateKeyCreator.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgPrivateKeyCreator.py index 48d5cdbfe..c4961db1c 100644 --- a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgPrivateKeyCreator.py +++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgPrivateKeyCreator.py @@ -42,59 +42,6 @@ class TestCfgPrivateKeyCreator(TestCfgCreator, TestStructFile): mock_HandleEvent.assert_called_with(pkc, evt) mock_handle_event.assert_called_with(pkc, evt) - def test_category(self): - pkc = self.get_obj() - pkc.setup = Mock() - pkc.setup.cfp = Mock() - pkc.setup.cfp.has_section.return_value = False - pkc.setup.cfp.has_option.return_value = False - - self.assertIsNone(pkc.category) - pkc.setup.cfp.has_section.assert_called_with("sshkeys") - - pkc.setup.reset_mock() - pkc.setup.cfp.has_section.return_value = True - self.assertIsNone(pkc.category) - pkc.setup.cfp.has_section.assert_called_with("sshkeys") - pkc.setup.cfp.has_option.assert_called_with("sshkeys", "category") - - pkc.setup.reset_mock() - pkc.setup.cfp.has_option.return_value = True - self.assertEqual(pkc.category, pkc.setup.cfp.get.return_value) - pkc.setup.cfp.has_section.assert_called_with("sshkeys") - pkc.setup.cfp.has_option.assert_called_with("sshkeys", "category") - pkc.setup.cfp.get.assert_called_with("sshkeys", "category") - - @skipUnless(HAS_CRYPTO, "No crypto libraries found, skipping") - @patchIf(HAS_CRYPTO, "Bcfg2.Server.Encryption.get_passphrases") - def test_passphrase(self, mock_get_passphrases): - pkc = self.get_obj() - pkc.setup = Mock() - pkc.setup.cfp = Mock() - pkc.setup.cfp.has_section.return_value = False - pkc.setup.cfp.has_option.return_value = False - - self.assertIsNone(pkc.passphrase) - pkc.setup.cfp.has_section.assert_called_with("sshkeys") - - pkc.setup.reset_mock() - pkc.setup.cfp.has_section.return_value = True - self.assertIsNone(pkc.passphrase) - pkc.setup.cfp.has_section.assert_called_with("sshkeys") - pkc.setup.cfp.has_option.assert_called_with("sshkeys", - "passphrase") - - pkc.setup.reset_mock() - pkc.setup.cfp.get.return_value = "test" - mock_get_passphrases.return_value = dict(test="foo", test2="bar") - pkc.setup.cfp.has_option.return_value = True - self.assertEqual(pkc.passphrase, "foo") - pkc.setup.cfp.has_section.assert_called_with("sshkeys") - pkc.setup.cfp.has_option.assert_called_with("sshkeys", - "passphrase") - pkc.setup.cfp.get.assert_called_with("sshkeys", "passphrase") - mock_get_passphrases.assert_called_with() - @patch("shutil.rmtree") @patch("tempfile.mkdtemp") def test__gen_keypair(self, mock_mkdtemp, mock_rmtree): @@ -153,52 +100,46 @@ class TestCfgPrivateKeyCreator(TestCfgCreator, TestStructFile): pkc.XMLMatch.reset_mock() metadata.group_in_category.reset_mock() - category = "Bcfg2.Server.Plugins.Cfg.CfgPrivateKeyCreator.CfgPrivateKeyCreator.category" - @patch(category, None) - def inner(): - pkc.XMLMatch.return_value = lxml.etree.Element("PrivateKey") - self.assertItemsEqual(pkc.get_specificity(metadata), - dict(host=metadata.hostname)) - inner() - - @patch(category, "foo") - def inner2(): - pkc.XMLMatch.return_value = lxml.etree.Element("PrivateKey") - self.assertItemsEqual(pkc.get_specificity(metadata), - dict(group=metadata.group_in_category.return_value, - prio=50)) - metadata.group_in_category.assert_called_with("foo") + Bcfg2.Options.setup.sshkeys_category = None + pkc.XMLMatch.return_value = lxml.etree.Element("PrivateKey") + self.assertItemsEqual(pkc.get_specificity(metadata), + dict(host=metadata.hostname)) - reset() - pkc.XMLMatch.return_value = lxml.etree.Element("PrivateKey", - perhost="true") - self.assertItemsEqual(pkc.get_specificity(metadata), - dict(host=metadata.hostname)) + Bcfg2.Options.setup.sshkeys_category = "foo" + pkc.XMLMatch.return_value = lxml.etree.Element("PrivateKey") + self.assertItemsEqual(pkc.get_specificity(metadata), + dict(group=metadata.group_in_category.return_value, + prio=50)) + metadata.group_in_category.assert_called_with("foo") - reset() - pkc.XMLMatch.return_value = lxml.etree.Element("PrivateKey", - category="bar") - self.assertItemsEqual(pkc.get_specificity(metadata), - dict(group=metadata.group_in_category.return_value, - prio=50)) - metadata.group_in_category.assert_called_with("bar") + reset() + pkc.XMLMatch.return_value = lxml.etree.Element("PrivateKey", + perhost="true") + self.assertItemsEqual(pkc.get_specificity(metadata), + dict(host=metadata.hostname)) - reset() - pkc.XMLMatch.return_value = lxml.etree.Element("PrivateKey", - prio="10") - self.assertItemsEqual(pkc.get_specificity(metadata), - dict(group=metadata.group_in_category.return_value, - prio=10)) - metadata.group_in_category.assert_called_with("foo") + reset() + pkc.XMLMatch.return_value = lxml.etree.Element("PrivateKey", + category="bar") + self.assertItemsEqual(pkc.get_specificity(metadata), + dict(group=metadata.group_in_category.return_value, + prio=50)) + metadata.group_in_category.assert_called_with("bar") - reset() - pkc.XMLMatch.return_value = lxml.etree.Element("PrivateKey") - metadata.group_in_category.return_value = '' - self.assertItemsEqual(pkc.get_specificity(metadata), - dict(host=metadata.hostname)) - metadata.group_in_category.assert_called_with("foo") + reset() + pkc.XMLMatch.return_value = lxml.etree.Element("PrivateKey", + prio="10") + self.assertItemsEqual(pkc.get_specificity(metadata), + dict(group=metadata.group_in_category.return_value, + prio=10)) + metadata.group_in_category.assert_called_with("foo") - inner2() + reset() + pkc.XMLMatch.return_value = lxml.etree.Element("PrivateKey") + metadata.group_in_category.return_value = '' + self.assertItemsEqual(pkc.get_specificity(metadata), + dict(host=metadata.hostname)) + metadata.group_in_category.assert_called_with("foo") @patch("shutil.rmtree") @patch("%s.open" % builtins) diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/Test_init.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/Test_init.py index 07a1b120e..72be50299 100644 --- a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/Test_init.py +++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/Test_init.py @@ -152,7 +152,7 @@ class TestCfgInfo(TestCfgBaseFileMatcher): @patch("Bcfg2.Server.Plugins.Cfg.CfgBaseFileMatcher.__init__") def test__init(self, mock__init): ci = self.get_obj("test.txt") - mock__init.assert_called_with(ci, "test.txt", None, None) + mock__init.assert_called_with(ci, "test.txt", None) def test_bind_info_to_entry(self): ci = self.get_obj() @@ -173,6 +173,10 @@ class TestCfgCreator(TestCfgBaseFileMatcher): test_obj = CfgCreator path = "/foo/bar/test.txt" + def setUp(self): + TestCfgBaseFileMatcher.setUp(self) + set_setup_default("filemonitor", MagicMock()) + def get_obj(self, name=None): if name is None: name = self.path @@ -269,31 +273,24 @@ class TestCfgDefaultInfo(TestCfgInfo): class TestCfgEntrySet(TestEntrySet): test_obj = CfgEntrySet + def setUp(self): + TestEntrySet.setUp(self) + set_setup_default("cfg_validation", False) + def test__init(self): pass - def test_handlers(self): - # this is really really difficult to mock out, so we just get - # a list of handlers and make sure that it roughly matches - # what's on the filesystem - expected = [] - for submodule in walk_packages(path=Bcfg2.Server.Plugins.Cfg.__path__, - prefix="Bcfg2.Server.Plugins.Cfg."): - expected.append(submodule[1].rsplit('.', 1)[-1]) - self.assertItemsEqual(expected, [h.__name__ for h in handlers()]) - - @patch("Bcfg2.Server.Plugins.Cfg.handlers") - def test_handle_event(self, mock_handlers): + def test_handle_event(self): eset = self.get_obj() eset.entry_init = Mock() - mock_handlers.return_value = [Mock(), Mock(), Mock()] - for hdlr in mock_handlers.return_value: + eset._handlers = [Mock(), Mock(), Mock()] + for hdlr in eset._handlers: hdlr.__name__ = "handler" eset.entries = dict() def reset(): eset.entry_init.reset_mock() - for hdlr in mock_handlers.return_value: + for hdlr in eset._handlers: hdlr.reset_mock() # test that a bogus deleted event is discarded @@ -303,7 +300,7 @@ class TestCfgEntrySet(TestEntrySet): eset.handle_event(evt) self.assertFalse(eset.entry_init.called) self.assertItemsEqual(eset.entries, dict()) - for hdlr in mock_handlers.return_value: + for hdlr in eset._handlers: self.assertFalse(hdlr.handles.called) self.assertFalse(hdlr.ignore.called) @@ -314,7 +311,7 @@ class TestCfgEntrySet(TestEntrySet): evt.filename = os.path.join(datastore, "test.txt") # test with no handler that handles - for hdlr in mock_handlers.return_value: + for hdlr in eset._handlers: hdlr.handles.return_value = False hdlr.ignore.return_value = False @@ -322,16 +319,16 @@ class TestCfgEntrySet(TestEntrySet): eset.handle_event(evt) self.assertFalse(eset.entry_init.called) self.assertItemsEqual(eset.entries, dict()) - for hdlr in mock_handlers.return_value: + for hdlr in eset._handlers: hdlr.handles.assert_called_with(evt, basename=eset.path) hdlr.ignore.assert_called_with(evt, basename=eset.path) # test with a handler that handles the entry reset() - mock_handlers.return_value[-1].handles.return_value = True + eset._handlers[-1].handles.return_value = True eset.handle_event(evt) - eset.entry_init.assert_called_with(evt, mock_handlers.return_value[-1]) - for hdlr in mock_handlers.return_value: + eset.entry_init.assert_called_with(evt, eset._handlers[-1]) + for hdlr in eset._handlers: hdlr.handles.assert_called_with(evt, basename=eset.path) if not hdlr.return_value: hdlr.ignore.assert_called_with(evt, basename=eset.path) @@ -339,14 +336,14 @@ class TestCfgEntrySet(TestEntrySet): # test with a handler that ignores the entry before one # that handles it reset() - mock_handlers.return_value[0].ignore.return_value = True + eset._handlers[0].ignore.return_value = True eset.handle_event(evt) self.assertFalse(eset.entry_init.called) - mock_handlers.return_value[0].handles.assert_called_with(evt, + eset._handlers[0].handles.assert_called_with(evt, + basename=eset.path) + eset._handlers[0].ignore.assert_called_with(evt, basename=eset.path) - mock_handlers.return_value[0].ignore.assert_called_with(evt, - basename=eset.path) - for hdlr in mock_handlers.return_value[1:]: + for hdlr in eset._handlers[1:]: self.assertFalse(hdlr.handles.called) self.assertFalse(hdlr.ignore.called) @@ -358,7 +355,7 @@ class TestCfgEntrySet(TestEntrySet): eset.entries[evt.filename] = Mock() eset.handle_event(evt) self.assertFalse(eset.entry_init.called) - for hdlr in mock_handlers.return_value: + for hdlr in eset._handlers: self.assertFalse(hdlr.handles.called) self.assertFalse(hdlr.ignore.called) eset.entries[evt.filename].handle_event.assert_called_with(evt) @@ -368,7 +365,7 @@ class TestCfgEntrySet(TestEntrySet): evt.code2str.return_value = "deleted" eset.handle_event(evt) self.assertFalse(eset.entry_init.called) - for hdlr in mock_handlers.return_value: + for hdlr in eset._handlers: self.assertFalse(hdlr.handles.called) self.assertFalse(hdlr.ignore.called) self.assertItemsEqual(eset.entries, dict()) @@ -422,6 +419,7 @@ class TestCfgEntrySet(TestEntrySet): def test_bind_entry(self, mock_b64encode, mock_u_str): mock_u_str.side_effect = lambda x: x + Bcfg2.Options.setup.cfg_validation = False eset = self.get_obj() eset.bind_info_to_entry = Mock() eset._generate_data = Mock() @@ -505,7 +503,7 @@ class TestCfgEntrySet(TestEntrySet): # test successful validation entry = reset() - eset.setup['validate'] = True + Bcfg2.Options.setup.cfg_validation = True bound = eset.bind_entry(entry, metadata) eset.bind_info_to_entry.assert_called_with(entry, metadata) eset._generate_data.assert_called_with(entry, metadata) @@ -527,16 +525,16 @@ class TestCfgEntrySet(TestEntrySet): def test_get_handlers(self): eset = self.get_obj() eset.entries['test1.txt'] = CfgInfo("test1.txt") - eset.entries['test2.txt'] = CfgGenerator("test2.txt", Mock(), None) + eset.entries['test2.txt'] = CfgGenerator("test2.txt", Mock()) eset.entries['test2.txt'].specific.matches.return_value = True eset.entries['test3.txt'] = CfgInfo("test3.txt") - eset.entries['test4.txt'] = CfgGenerator("test4.txt", Mock(), None) + eset.entries['test4.txt'] = CfgGenerator("test4.txt", Mock()) eset.entries['test4.txt'].specific.matches.return_value = False - eset.entries['test5.txt'] = CfgGenerator("test5.txt", Mock(), None) + eset.entries['test5.txt'] = CfgGenerator("test5.txt", Mock()) eset.entries['test5.txt'].specific.matches.return_value = True - eset.entries['test6.txt'] = CfgVerifier("test6.txt", Mock(), None) + eset.entries['test6.txt'] = CfgVerifier("test6.txt", Mock()) eset.entries['test6.txt'].specific.matches.return_value = True - eset.entries['test7.txt'] = CfgFilter("test7.txt", Mock(), None) + eset.entries['test7.txt'] = CfgFilter("test7.txt", Mock()) eset.entries['test7.txt'].specific.matches.return_value = False def reset(): @@ -737,38 +735,6 @@ class TestCfg(TestGroupSpool, TestPullTarget): core = Mock() return TestGroupSpool.get_obj(self, core=core) - @patch("Bcfg2.Options.get_option_parser") - @patch("Bcfg2.Server.Plugin.GroupSpool.__init__") - @patch("Bcfg2.Server.Plugin.PullTarget.__init__") - def test__init(self, mock_pulltarget_init, mock_groupspool_init, - mock_get_option_parser): - setup = MagicMock() - setup.__contains__.return_value = False - mock_get_option_parser.return_value = setup - - def reset(): - core.reset_mock() - setup.reset_mock() - mock_pulltarget_init.reset_mock() - mock_groupspool_init.reset_mock() - - core = Mock() - cfg = self.test_obj(core, datastore) - mock_pulltarget_init.assert_called_with(cfg) - mock_groupspool_init.assert_called_with(cfg, core, datastore) - setup.add_option.assert_called_with( - "validate", - Bcfg2.Options.CFG_VALIDATION) - mock_get_option_parser.return_value.reparse.assert_called_with() - - reset() - setup.__contains__.return_value = True - cfg = self.test_obj(core, datastore) - mock_pulltarget_init.assert_called_with(cfg) - mock_groupspool_init.assert_called_with(cfg, core, datastore) - self.assertFalse(setup.add_option.called) - self.assertFalse(setup.reparse.called) - def test_has_generator(self): cfg = self.get_obj() cfg.entries = dict() diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestMetadata.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestMetadata.py index 90f592eb2..274b5e302 100644 --- a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestMetadata.py +++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestMetadata.py @@ -6,7 +6,6 @@ import socket import lxml.etree import Bcfg2.Server import Bcfg2.Server.Plugin -from Bcfg2.Server.Plugins.Metadata import * from mock import Mock, MagicMock, patch # add all parent testsuite directories to sys.path to allow (most) @@ -19,9 +18,13 @@ while path != "/": break path = os.path.dirname(path) from common import * +from Bcfg2.Server.Plugins.Metadata import load_django_models from TestPlugin import TestXMLFileBacked, TestMetadata as _TestMetadata, \ TestClientRunHooks, TestDatabaseBacked +load_django_models() +from Bcfg2.Server.Plugins.Metadata import * + def get_clients_test_tree(): return lxml.etree.XML(''' @@ -88,13 +91,12 @@ def get_groups_test_tree(): ''').getroottree() -def get_metadata_object(core=None, watch_clients=False, use_db=False): +def get_metadata_object(core=None, watch_clients=False): if core is None: core = Mock() - core.setup = MagicMock() core.metadata_cache = MagicMock() - core.setup.cfp.getboolean = Mock(return_value=use_db) + set_setup_default("password") @patchIf(not isinstance(os.makedirs, Mock), "os.makedirs", Mock()) @patchIf(not isinstance(lxml.etree.Element, Mock), "lxml.etree.Element", Mock()) @@ -119,6 +121,7 @@ if HAS_DJANGO or can_skip: @skipUnless(HAS_DJANGO, "Django not found") def setUp(self): + TestDatabaseBacked.setUp(self) self.test_obj = ClientVersions syncdb(TestMetadataDB) for client, version in self.test_clients.items(): @@ -476,11 +479,16 @@ class TestClientMetadata(Bcfg2TestCase): class TestMetadata(_TestMetadata, TestClientRunHooks, TestDatabaseBacked): test_obj = Metadata - use_db = False + + def setUp(self): + _TestMetadata.setUp(self) + TestClientRunHooks.setUp(self) + TestDatabaseBacked.setUp(self) + Bcfg2.Options.setup.metadata_db = False + Bcfg2.Options.setup.authentication = "cert+password" def get_obj(self, core=None, watch_clients=False): - return get_metadata_object(core=core, watch_clients=watch_clients, - use_db=self.use_db) + return get_metadata_object(core=core, watch_clients=watch_clients) @skipUnless(HAS_DJANGO, "Django not found") def test__use_db(self): @@ -767,7 +775,7 @@ class TestMetadata(_TestMetadata, TestClientRunHooks, TestDatabaseBacked): metadata.clients_xml.xdata = copy.deepcopy(get_clients_test_tree()) metadata._handle_clients_xml_event(Mock()) - if not self.use_db: + if not Bcfg2.Options.setup.metadata_db: self.assertItemsEqual(metadata.clients, dict([(c.get("name"), c.get("profile")) for c in get_clients_test_tree().findall("//Client")])) @@ -1259,10 +1267,13 @@ class TestMetadata(_TestMetadata, TestClientRunHooks, TestDatabaseBacked): class TestMetadataBase(TestMetadata): """ base test object for testing Metadata with database enabled """ __test__ = False - use_db = True @skipUnless(HAS_DJANGO, "Django not found") def setUp(self): + _TestMetadata.setUp(self) + TestClientRunHooks.setUp(self) + TestDatabaseBacked.setUp(self) + Bcfg2.Options.setup.metadata_db = True syncdb(TestMetadataDB) def load_clients_data(self, metadata=None, xdata=None): diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestProbes.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestProbes.py index f44bc338c..b0e6e9142 100644 --- a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestProbes.py +++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestProbes.py @@ -18,10 +18,19 @@ while path != "/": break path = os.path.dirname(path) from common import * -from Bcfg2.Server.Plugins.Probes import * +from Bcfg2.Server.Plugins.Probes import load_django_models from TestPlugin import TestEntrySet, TestProbing, TestConnector, \ TestDatabaseBacked +load_django_models() +from Bcfg2.Server.Plugins.Probes import * + +if HAS_JSON: + json = json + +if HAS_YAML: + yaml = yaml + # test data for JSON and YAML tests test_data = dict(a=1, b=[1, 2, 3], c="test", d=dict(a=1, b=dict(a=1), c=(1, "2", 3))) @@ -74,7 +83,8 @@ class FakeList(list): class TestProbesDB(DBModelTestCase): if HAS_DJANGO: - models = [ProbesGroupsModel, ProbesDataModel] + models = [ProbesGroupsModel, + ProbesDataModel] class TestClientProbeDataSet(Bcfg2TestCase): @@ -108,19 +118,22 @@ class TestProbeData(Bcfg2TestCase): def test_xdata(self): xdata = lxml.etree.Element("test") lxml.etree.SubElement(xdata, "test2") - data = ProbeData(lxml.etree.tostring(xdata, - xml_declaration=False).decode('UTF-8')) + data = ProbeData( + lxml.etree.tostring(xdata, + xml_declaration=False).decode('UTF-8')) self.assertIsNotNone(data.xdata) self.assertIsNotNone(data.xdata.find("test2")) - @skipUnless(HAS_JSON, "JSON libraries not found, skipping JSON tests") + @skipUnless(HAS_JSON, + "JSON libraries not found, skipping JSON tests") def test_json(self): jdata = json.dumps(test_data) data = ProbeData(jdata) self.assertIsNotNone(data.json) self.assertItemsEqual(test_data, data.json) - @skipUnless(HAS_YAML, "YAML libraries not found, skipping YAML tests") + @skipUnless(HAS_YAML, + "YAML libraries not found, skipping YAML tests") def test_yaml(self): jdata = yaml.dump(test_data) data = ProbeData(jdata) @@ -139,7 +152,7 @@ class TestProbeSet(TestEntrySet): # get_obj() accepts the basename argument, accepted by the # parent get_obj() method, and just throws it away, since # ProbeSet uses a regex for the "basename" - rv = self.test_obj(path, encoding, plugin_name) + rv = self.test_obj(path, plugin_name) rv.entry_type = MagicMock() return rv @@ -243,30 +256,47 @@ group-specific""" class TestProbes(TestProbing, TestConnector, TestDatabaseBacked): test_obj = Probes - def get_obj(self, core=None): - return TestDatabaseBacked.get_obj(self, core=core) + def get_obj(self, core=None, load_data=None): + core = MagicMock() + if load_data is None: + load_data = MagicMock() + + @patch("%s.%s.load_data" % (self.test_obj.__module__, + self.test_obj.__name__), new=load_data) + def inner(): + return TestDatabaseBacked.get_obj(self, core=core) + + return inner() def get_test_probedata(self): test_xdata = lxml.etree.Element("test") lxml.etree.SubElement(test_xdata, "test", foo="foo") rv = dict() - rv["foo.example.com"] = ClientProbeDataSet(timestamp=time.time()) + rv["foo.example.com"] = ClientProbeDataSet( + timestamp=time.time()) rv["foo.example.com"]["xml"] = \ - ProbeData(lxml.etree.tostring(test_xdata, - xml_declaration=False).decode('UTF-8')) - rv["foo.example.com"]["text"] = ProbeData("freeform text") - rv["foo.example.com"]["multiline"] = ProbeData("""multiple + ProbeData(lxml.etree.tostring( + test_xdata, + xml_declaration=False).decode('UTF-8')) + rv["foo.example.com"]["text"] = \ + ProbeData("freeform text") + rv["foo.example.com"]["multiline"] = \ + ProbeData("""multiple lines of freeform text """) - rv["bar.example.com"] = ClientProbeDataSet(timestamp=time.time()) - rv["bar.example.com"]["empty"] = ProbeData("") + rv["bar.example.com"] = ClientProbeDataSet( + timestamp=time.time()) + rv["bar.example.com"]["empty"] = \ + ProbeData("") if HAS_JSON: - rv["bar.example.com"]["json"] = ProbeData(json.dumps(test_data)) + rv["bar.example.com"]["json"] = \ + ProbeData(json.dumps(test_data)) if HAS_YAML: - rv["bar.example.com"]["yaml"] = ProbeData(yaml.dump(test_data)) + rv["bar.example.com"]["yaml"] = \ + ProbeData(yaml.dump(test_data)) return rv def get_test_cgroups(self): @@ -274,62 +304,36 @@ text "group-with-dashes"], "bar.example.com": []} - def get_probes_object(self, use_db=False, load_data=None): - core = MagicMock() - core.setup.cfp.getboolean = Mock() - core.setup.cfp.getboolean.return_value = use_db - if load_data is None: - load_data = MagicMock() - # we have to patch load_data() in a funny way because - # different versions of Mock have different scopes for - # patching. in some versions, a patch applied to - # get_probes_object() would only apply to that function, while - # in others it would also apply to the calling function (e.g., - # test__init(), which relies on being able to check the calls - # of load_data(), and thus on load_data() being consistently - # mocked) - @patch("%s.%s.load_data" % (self.test_obj.__module__, - self.test_obj.__name__), new=load_data) - def inner(): - return self.get_obj(core) - - return inner() - def test__init(self): mock_load_data = Mock() - probes = self.get_probes_object(load_data=mock_load_data) + probes = self.get_obj(load_data=mock_load_data) mock_load_data.assert_any_call() - self.assertEqual(probes.probedata, ClientProbeDataSet()) + self.assertEqual(probes.probedata, + ClientProbeDataSet()) self.assertEqual(probes.cgroups, dict()) - @patch("Bcfg2.Server.Plugins.Probes.Probes.load_data", Mock()) - def test__use_db(self): - probes = self.get_probes_object() - self.assertFalse(probes._use_db) - probes.core.setup.cfp.getboolean.assert_called_with("probes", - "use_database", - default=False) - - @skipUnless(HAS_DJANGO, "Django not found, skipping") - @patch("Bcfg2.Server.Plugins.Probes.Probes._write_data_db", Mock()) - @patch("Bcfg2.Server.Plugins.Probes.Probes._write_data_xml", Mock()) def test_write_data_xml(self): - probes = self.get_probes_object(use_db=False) + Bcfg2.Options.setup.probes_db = False + probes = self.get_obj() + probes._write_data_db = Mock() + probes._write_data_xml = Mock() probes.write_data("test") probes._write_data_xml.assert_called_with("test") self.assertFalse(probes._write_data_db.called) @skipUnless(HAS_DJANGO, "Django not found, skipping") - @patch("Bcfg2.Server.Plugins.Probes.Probes._write_data_db", Mock()) - @patch("Bcfg2.Server.Plugins.Probes.Probes._write_data_xml", Mock()) def test_write_data_db(self): - probes = self.get_probes_object(use_db=True) + Bcfg2.Options.setup.probes_db = True + probes = self.get_obj() + probes._write_data_db = Mock() + probes._write_data_xml = Mock() probes.write_data("test") probes._write_data_db.assert_called_with("test") self.assertFalse(probes._write_data_xml.called) def test__write_data_xml(self): - probes = self.get_probes_object(use_db=False) + Bcfg2.Options.setup.probes_db = False + probes = self.get_obj() probes.probedata = self.get_test_probedata() probes.cgroups = self.get_test_cgroups() @@ -397,7 +401,8 @@ text @skipUnless(HAS_DJANGO, "Django not found, skipping") def test__write_data_db(self): syncdb(TestProbesDB) - probes = self.get_probes_object(use_db=True) + Bcfg2.Options.setup.probes_db = True + probes = self.get_obj() probes.probedata = self.get_test_probedata() probes.cgroups = self.get_test_cgroups() @@ -446,27 +451,29 @@ text pgroups = ProbesGroupsModel.objects.filter(hostname=cname).all() self.assertEqual(len(pgroups), len(probes.cgroups[cname])) - @skipUnless(HAS_DJANGO, "Django not found, skipping") - @patch("Bcfg2.Server.Plugins.Probes.Probes._load_data_db", Mock()) - @patch("Bcfg2.Server.Plugins.Probes.Probes._load_data_xml", Mock()) def test_load_data_xml(self): - probes = self.get_probes_object(use_db=False) + Bcfg2.Options.setup.probes_db = False + probes = self.get_obj() + probes._load_data_db = Mock() + probes._load_data_xml = Mock() probes.load_data() probes._load_data_xml.assert_any_call() self.assertFalse(probes._load_data_db.called) @skipUnless(HAS_DJANGO, "Django not found, skipping") - @patch("Bcfg2.Server.Plugins.Probes.Probes._load_data_db", Mock()) - @patch("Bcfg2.Server.Plugins.Probes.Probes._load_data_xml", Mock()) def test_load_data_db(self): - probes = self.get_probes_object(use_db=True) + Bcfg2.Options.setup.probes_db = True + probes = self.get_obj() + probes._load_data_db = Mock() + probes._load_data_xml = Mock() probes.load_data() probes._load_data_db.assert_any_call(client=None) self.assertFalse(probes._load_data_xml.called) @patch("lxml.etree.parse") def test__load_data_xml(self, mock_parse): - probes = self.get_probes_object(use_db=False) + Bcfg2.Options.setup.probes_db = False + probes = self.get_obj() probes.probedata = self.get_test_probedata() probes.cgroups = self.get_test_cgroups() @@ -496,7 +503,8 @@ text @skipUnless(HAS_DJANGO, "Django not found, skipping") def test__load_data_db(self): syncdb(TestProbesDB) - probes = self.get_probes_object(use_db=True) + Bcfg2.Options.setup.probes_db = True + probes = self.get_obj() probes.probedata = self.get_test_probedata() probes.cgroups = self.get_test_cgroups() for cname in probes.probedata.keys(): @@ -521,19 +529,19 @@ text @patch("Bcfg2.Server.Plugins.Probes.ProbeSet.get_probe_data") def test_GetProbes(self, mock_get_probe_data): - probes = self.get_probes_object() + probes = self.get_obj() metadata = Mock() probes.GetProbes(metadata) mock_get_probe_data.assert_called_with(metadata) - @patch("Bcfg2.Server.Plugins.Probes.Probes.write_data") - @patch("Bcfg2.Server.Plugins.Probes.Probes.ReceiveDataItem") - def test_ReceiveData(self, mock_ReceiveDataItem, mock_write_data): + def test_ReceiveData(self): # we use a simple (read: bogus) datalist here to make this # easy to test datalist = ["a", "b", "c"] - probes = self.get_probes_object() + probes = self.get_obj() + probes.write_data = Mock() + probes.ReceiveDataItem = Mock() probes.core.metadata_cache_mode = 'off' client = Mock() client.hostname = "foo.example.com" @@ -541,11 +549,11 @@ text cgroups = [] cprobedata = ClientProbeDataSet() - self.assertItemsEqual(mock_ReceiveDataItem.call_args_list, + self.assertItemsEqual(probes.ReceiveDataItem.call_args_list, [call(client, "a", cgroups, cprobedata), call(client, "b", cgroups, cprobedata), call(client, "c", cgroups, cprobedata)]) - mock_write_data.assert_called_with(client) + probes.write_data.assert_called_with(client) self.assertFalse(probes.core.metadata_cache.expire.called) # change the datalist, ensure that the cache is cleared @@ -553,11 +561,11 @@ text probes.core.metadata_cache_mode = 'aggressive' probes.ReceiveData(client, ['a', 'b', 'd']) - mock_write_data.assert_called_with(client) + probes.write_data.assert_called_with(client) probes.core.metadata_cache.expire.assert_called_with(client.hostname) def test_ReceiveDataItem(self): - probes = self.get_probes_object() + probes = self.get_obj() for cname, cdata in self.get_test_probedata().items(): client = Mock() client.hostname = cname @@ -589,7 +597,7 @@ text def test_get_additional_groups(self): TestConnector.test_get_additional_groups(self) - probes = self.get_probes_object() + probes = self.get_obj() test_cgroups = self.get_test_cgroups() probes.cgroups = self.get_test_cgroups() for cname in test_cgroups.keys(): @@ -606,7 +614,7 @@ text def test_get_additional_data(self): TestConnector.test_get_additional_data(self) - probes = self.get_probes_object() + probes = self.get_obj() test_probedata = self.get_test_probedata() probes.probedata = self.get_test_probedata() for cname in test_probedata.keys(): diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestProperties.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestProperties.py index 92dc85fb1..9fa2cc4db 100644 --- a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestProperties.py +++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestProperties.py @@ -30,6 +30,7 @@ class TestPropertyFile(Bcfg2TestCase): path = os.path.join(datastore, "test") def get_obj(self, path=None): + set_setup_default("writes_enabled", False) if path is None: path = self.path return self.test_obj(path) @@ -38,7 +39,6 @@ class TestPropertyFile(Bcfg2TestCase): pf = self.get_obj() pf.validate_data = Mock() pf._write = Mock() - pf.setup = Mock() xstr = u("\n") pf.xdata = lxml.etree.XML(xstr) @@ -46,20 +46,16 @@ class TestPropertyFile(Bcfg2TestCase): def reset(): pf.validate_data.reset_mock() pf._write.reset_mock() - pf.setup.reset_mock() # test writes disabled - pf.setup.cfp.getboolean.return_value = False + Bcfg2.Options.setup.writes_enabled = False self.assertRaises(PluginExecutionError, pf.write) self.assertFalse(pf.validate_data.called) self.assertFalse(pf._write.called) - pf.setup.cfp.getboolean.assert_called_with("properties", - "writes_enabled", - default=True) # test successful write reset() - pf.setup.cfp.getboolean.return_value = True + Bcfg2.Options.setup.writes_enabled = True self.assertEqual(pf.write(), pf._write.return_value) pf.validate_data.assert_called_with() pf._write.assert_called_with() @@ -97,12 +93,10 @@ if can_skip or HAS_JSON: class TestJSONPropertyFile(TestFileBacked, TestPropertyFile): test_obj = JSONPropertyFile - def get_obj(self, *args, **kwargs): - return TestFileBacked.get_obj(self, *args, **kwargs) - @skipUnless(HAS_JSON, "JSON libraries not found, skipping") def setUp(self): - pass + TestFileBacked.setUp(self) + TestPropertyFile.setUp(self) @patch("%s.loads" % JSON) def test_Index(self, mock_loads): @@ -140,12 +134,10 @@ if can_skip or HAS_YAML: class TestYAMLPropertyFile(TestFileBacked, TestPropertyFile): test_obj = YAMLPropertyFile - def get_obj(self, *args, **kwargs): - return TestFileBacked.get_obj(self, *args, **kwargs) - @skipUnless(HAS_YAML, "YAML libraries not found, skipping") def setUp(self): - pass + TestFileBacked.setUp(self) + TestPropertyFile.setUp(self) @patch("yaml.load") def test_Index(self, mock_load): @@ -183,6 +175,11 @@ class TestXMLPropertyFile(TestPropertyFile, TestStructFile): test_obj = XMLPropertyFile path = TestStructFile.path + def setUp(self): + TestPropertyFile.setUp(self) + TestStructFile.setUp(self) + set_setup_default("automatch", False) + def get_obj(self, *args, **kwargs): return TestStructFile.get_obj(self, *args, **kwargs) @@ -250,48 +247,34 @@ class TestXMLPropertyFile(TestPropertyFile, TestStructFile): pf.setup.reset_mock() pf.xdata = lxml.etree.Element("Properties", automatch="true") - for automatch in [True, False]: + for Bcfg2.Options.setup.automatch in [True, False]: reset() - pf.setup.cfp.getboolean.return_value = automatch self.assertEqual(pf.get_additional_data(metadata), pf.XMLMatch.return_value) pf.XMLMatch.assert_called_with(metadata) - pf.setup.cfp.getboolean.assert_called_with("properties", - "automatch", - default=False) self.assertFalse(mock_copy.called) pf.xdata = lxml.etree.Element("Properties", automatch="false") - for automatch in [True, False]: + for Bcfg2.Options.setup.automatch in [True, False]: reset() - pf.setup.cfp.getboolean.return_value = automatch self.assertEqual(pf.get_additional_data(metadata), mock_copy.return_value) mock_copy.assert_called_with(pf) self.assertFalse(pf.XMLMatch.called) - pf.setup.cfp.getboolean.assert_called_with("properties", - "automatch", - default=False) pf.xdata = lxml.etree.Element("Properties") reset() - pf.setup.cfp.getboolean.return_value = False + Bcfg2.Options.setup.automatch = False self.assertEqual(pf.get_additional_data(metadata), mock_copy.return_value) mock_copy.assert_called_with(pf) self.assertFalse(pf.XMLMatch.called) - pf.setup.cfp.getboolean.assert_called_with("properties", - "automatch", - default=False) reset() - pf.setup.cfp.getboolean.return_value = True + Bcfg2.Options.setup.automatch = True self.assertEqual(pf.get_additional_data(metadata), pf.XMLMatch.return_value) pf.XMLMatch.assert_called_with(metadata) - pf.setup.cfp.getboolean.assert_called_with("properties", - "automatch", - default=False) self.assertFalse(mock_copy.called) diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestRules.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestRules.py index 7083fff06..0bd69b371 100644 --- a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestRules.py +++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestRules.py @@ -21,6 +21,10 @@ from TestPlugin import TestPrioDir class TestRules(TestPrioDir): test_obj = Rules + def setUp(self): + TestPrioDir.setUp(self) + set_setup_default("rules_regex", False) + def test_HandlesEntry(self): r = self.get_obj() r.Entries = dict(Path={"/etc/foo.conf": Mock(), @@ -76,11 +80,3 @@ class TestRules(TestPrioDir): self.assertTrue(r._matches(entry, metadata, candidate)) mock_matches.assert_called_with(r, entry, metadata, candidate) self.assertIn("/etc/.*\.conf", r._regex_cache.keys()) - - def test__regex_enabled(self): - r = self.get_obj() - r.core.setup = MagicMock() - self.assertEqual(r._regex_enabled, - r.core.setup.cfp.getboolean.return_value) - r.core.setup.cfp.getboolean.assert_called_with("rules", "regex", - default=False) -- cgit v1.2.3-1-g7c22