From 53d5423f3e5e09812c751360ba53f0a2639d2f29 Mon Sep 17 00:00:00 2001 From: "Chris St. Pierre" Date: Thu, 9 Aug 2012 11:31:25 -0400 Subject: adding some tests for Plugin.py --- testsuite/Testlib/TestServer/TestPlugin.py | 448 +++++++++++++++++++++++++++++ 1 file changed, 448 insertions(+) create mode 100644 testsuite/Testlib/TestServer/TestPlugin.py (limited to 'testsuite') diff --git a/testsuite/Testlib/TestServer/TestPlugin.py b/testsuite/Testlib/TestServer/TestPlugin.py new file mode 100644 index 000000000..0d1c0f810 --- /dev/null +++ b/testsuite/Testlib/TestServer/TestPlugin.py @@ -0,0 +1,448 @@ +import os +import copy +import logging +import unittest +import lxml.etree +from mock import Mock, MagicMock, patch +from Bcfg2.Server.Plugin import * +import Bcfg2.Server +import Bcfg2.Server.Plugins.Metadata + +datastore = '/' + +def call(*args, **kwargs): + """ the Mock call object is a fairly recent addition, but it's + very very useful, so we create our own function to create Mock + calls """ + return (args, kwargs) + + +class TestFunctions(unittest.TestCase): + def test_bind_info(self): + entry = lxml.etree.Element("Path", name="/test") + metadata = Mock() + default = dict(test1="test1", test2="test2") + # test without infoxml + bind_info(entry, metadata, default=default) + self.assertItemsEqual(entry.attrib, + dict(test1="test1", + test2="test2", + name="/test")) + + # test with bogus infoxml + entry = lxml.etree.Element("Path", name="/test") + infoxml = Mock() + self.assertRaises(PluginExecutionError, + bind_info, + entry, metadata, infoxml=infoxml) + infoxml.pnode.Match.assert_called_with(metadata, dict(), entry=entry) + + # test with valid infoxml + entry = lxml.etree.Element("Path", name="/test") + infoxml.reset_mock() + infodata = {None: {"test3": "test3", "test4": "test4"}} + def infoxml_rv(metadata, rv, entry=None): + rv['Info'] = infodata + infoxml.pnode.Match.side_effect = infoxml_rv + bind_info(entry, metadata, infoxml=infoxml, default=default) + # mock objects don't properly track the called-with value of + # arguments whose value is changed by the function, so it + # thinks Match() was called with the final value of the mdata + # arg, not the initial value. makes this test a little less + # worthwhile, TBH. + infoxml.pnode.Match.assert_called_with(metadata, dict(Info=infodata), + entry=entry) + self.assertItemsEqual(entry.attrib, + dict(test1="test1", + test2="test2", + test3="test3", + test4="test4", + name="/test")) + + +class TestPluginInitError(unittest.TestCase): + """ placeholder for future tests """ + pass + + +class TestPluginExecutionError(unittest.TestCase): + """ placeholder for future tests """ + pass + + +class TestDebuggable(unittest.TestCase): + def test__init(self): + d = Debuggable() + self.assertIsInstance(d.logger, logging.Logger) + self.assertFalse(d.debug_flag) + + @patch("Bcfg2.Server.Plugin.Debuggable.debug_log") + def test_toggle_debug(self, mock_debug): + d = Debuggable() + orig = d.debug_flag + d.toggle_debug() + self.assertNotEqual(orig, d.debug_flag) + self.assertTrue(mock_debug.called) + + mock_debug.reset_mock() + + changed = d.debug_flag + d.toggle_debug() + self.assertNotEqual(changed, d.debug_flag) + self.assertEqual(orig, d.debug_flag) + self.assertTrue(mock_debug.called) + + def test_debug_log(self): + d = Debuggable() + 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) + + +class TestPlugin(unittest.TestCase): + def test__init(self): + core = Mock() + p = Plugin(core, datastore) + self.assertEqual(p.data, os.path.join(datastore, p.name)) + self.assertEqual(p.core, core) + self.assertIsInstance(p, Debuggable) + + @patch("os.makedirs") + def test_init_repo(self, mock_makedirs): + Plugin.init_repo(datastore) + mock_makedirs.assert_called_with(os.path.join(datastore, Plugin.name)) + + +class TestDatabaseBacked(unittest.TestCase): + @unittest.skipUnless(has_django, "Django not found") + def test__use_db(self): + core = Mock() + core.setup.cfp.getboolean.return_value = True + db = DatabaseBacked(core, datastore) + self.assertTrue(db._use_db) + + core = Mock() + core.setup.cfp.getboolean.return_value = False + db = DatabaseBacked(core, datastore) + self.assertFalse(db._use_db) + + Bcfg2.Server.Plugin.has_django = False + core = Mock() + db = DatabaseBacked(core, datastore) + self.assertFalse(db._use_db) + + core = Mock() + core.setup.cfp.getboolean.return_value = True + db = DatabaseBacked(core, datastore) + self.assertFalse(db._use_db) + Bcfg2.Server.Plugin.has_django = True + + +class TestPluginDatabaseModel(unittest.TestCase): + """ placeholder for future tests """ + pass + + +class TestGenerator(unittest.TestCase): + def test_HandleEntry(self): + g = Generator() + self.assertRaises(NotImplementedError, + g.HandleEntry, None, None) + + +class TestStructure(unittest.TestCase): + def test_BuildStructures(self): + s = Structure() + self.assertRaises(NotImplementedError, + s.BuildStructures, None) + + +class TestMetadata(unittest.TestCase): + def test_get_initial_metadata(self): + m = Metadata() + self.assertRaises(NotImplementedError, + m.get_initial_metadata, None) + + def test_merge_additional_data(self): + m = Metadata() + self.assertRaises(NotImplementedError, + m.merge_additional_data, None, None, None) + + def test_merge_additional_groups(self): + m = Metadata() + self.assertRaises(NotImplementedError, + m.merge_additional_groups, None, None) + + +class TestConnector(unittest.TestCase): + """ placeholder """ + pass + + +class TestProbing(unittest.TestCase): + """ placeholder """ + pass + + +class TestStatistics(unittest.TestCase): + """ placeholder """ + pass + + +class TestThreadedStatistics(unittest.TestCase): + data = [("foo.example.com", ""), + ("bar.example.com", "")] + + @patch("threading.Thread.start") + def test__init(self, mock_start): + core = Mock() + ts = ThreadedStatistics(core, datastore) + mock_start.assert_any_call() + + @patch("__builtin__.open") + @patch("Bcfg2.Server.Plugin.ThreadedStatistics.run", Mock()) + def test_save(self, mock_open): + core = Mock() + ts = ThreadedStatistics(core, datastore) + queue = Mock() + queue.empty = Mock(side_effect=Empty) + ts.work_queue = queue + + mock_open.side_effect = OSError + # test that save does _not_ raise an exception even when + # everything goes pear-shaped + ts.save() + queue.empty.assert_any_call() + mock_open.assert_called_with(ts.pending_file, 'w') + + queue.reset_mock() + mock_open.reset_mock() + + queue.data = [] + for hostname, xml in self.data: + md = Mock() + md.hostname = hostname + queue.data.append((md, lxml.etree.XML(xml))) + queue.empty.side_effect = lambda: len(queue.data) == 0 + queue.get_nowait = Mock(side_effect=lambda: queue.data.pop()) + mock_open.side_effect = None + + # oh, the joy of working around different package names in + # py3k... + with patch("%s.dump" % cPickle.__name__) as mock_dump: + ts.save() + queue.empty.assert_any_call() + queue.get_nowait.assert_any_call() + mock_open.assert_called_with(ts.pending_file, 'w') + mock_open.return_value.close.assert_any_call() + # the order of the queue data gets changed, so we have to + # verify this call in an ugly way + self.assertItemsEqual(mock_dump.call_args[0][0], self.data) + self.assertEqual(mock_dump.call_args[0][1], mock_open.return_value) + + @patch("os.unlink") + @patch("os.path.exists") + @patch("__builtin__.open") + @patch("lxml.etree.XML") + @patch("Bcfg2.Server.Plugin.ThreadedStatistics.run", Mock()) + def test_load(self, mock_XML, mock_open, mock_exists, mock_unlink): + core = Mock() + core.terminate.isSet.return_value = False + ts = ThreadedStatistics(core, datastore) + + with patch("%s.load" % cPickle.__name__) as mock_load: + ts.work_queue = Mock() + ts.work_queue.data = [] + def reset(): + core.reset_mock() + mock_open.reset_mock() + mock_exists.reset_mock() + mock_unlink.reset_mock() + mock_load.reset_mock() + mock_XML.reset_mock() + ts.work_queue.reset_mock() + ts.work_queue.data = [] + + mock_exists.return_value = False + self.assertTrue(ts.load()) + mock_exists.assert_called_with(ts.pending_file) + + reset() + mock_exists.return_value = True + mock_open.side_effect = OSError + self.assertFalse(ts.load()) + mock_exists.assert_called_with(ts.pending_file) + mock_open.assert_called_with(ts.pending_file, 'r') + + reset() + mock_open.side_effect = None + mock_load.return_value = self.data + ts.work_queue.put_nowait.side_effect = Full + self.assertTrue(ts.load()) + mock_exists.assert_called_with(ts.pending_file) + mock_open.assert_called_with(ts.pending_file, 'r') + mock_open.return_value.close.assert_any_call() + mock_load.assert_called_with(mock_open.return_value) + + reset() + core.build_metadata.side_effect = lambda x: x + mock_XML.side_effect = lambda x, parser=None: x + ts.work_queue.put_nowait.side_effect = None + self.assertTrue(ts.load()) + mock_exists.assert_called_with(ts.pending_file) + mock_open.assert_called_with(ts.pending_file, 'r') + mock_open.return_value.close.assert_any_call() + mock_load.assert_called_with(mock_open.return_value) + self.assertItemsEqual(mock_XML.call_args_list, + [call(x, parser=Bcfg2.Server.XMLParser) + for h, x in self.data]) + self.assertItemsEqual(ts.work_queue.put_nowait.call_args_list, + [call((h, x)) for h, x in self.data]) + mock_unlink.assert_called_with(ts.pending_file) + + @patch("threading.Thread.start", Mock()) + @patch("Bcfg2.Server.Plugin.ThreadedStatistics.load") + @patch("Bcfg2.Server.Plugin.ThreadedStatistics.save") + @patch("Bcfg2.Server.Plugin.ThreadedStatistics.handle_statistic") + def test_run(self, mock_handle, mock_save, mock_load): + core = Mock() + ts = ThreadedStatistics(core, datastore) + mock_load.return_value = True + ts.work_queue = Mock() + + def reset(): + mock_handle.reset_mock() + mock_save.reset_mock() + mock_load.reset_mock() + core.reset_mock() + ts.work_queue.reset_mock() + ts.work_queue.data = self.data[:] + ts.work_queue.get_calls = 0 + + reset() + + def get_rv(**kwargs): + ts.work_queue.get_calls += 1 + try: + return ts.work_queue.data.pop() + except: + raise Empty + ts.work_queue.get.side_effect = get_rv + def terminate_isset(): + # this lets the loop go on a few iterations with an empty + # queue to test that it doesn't error out + return ts.work_queue.get_calls > 3 + core.terminate.isSet.side_effect = terminate_isset + + ts.run() + mock_load.assert_any_call() + self.assertGreaterEqual(ts.work_queue.get.call_count, len(self.data)) + self.assertItemsEqual(mock_handle.call_args_list, + [call(h, x) for h, x in self.data]) + mock_save.assert_any_call() + + @patch("copy.copy", Mock(side_effect=lambda x: x)) + @patch("Bcfg2.Server.Plugin.ThreadedStatistics.run", Mock()) + def test_process_statistics(self): + core = Mock() + ts = ThreadedStatistics(core, datastore) + ts.work_queue = Mock() + ts.process_statistics(*self.data[0]) + ts.work_queue.put_nowait.assert_called_with(self.data[0]) + + ts.work_queue.reset_mock() + ts.work_queue.put_nowait.side_effect = Full + # test that no exception is thrown + ts.process_statistics(*self.data[0]) + + +class TestPullSource(unittest.TestCase): + def test_GetCurrentEntry(self): + ps = PullSource() + self.assertRaises(NotImplementedError, + ps.GetCurrentEntry, None, None, None) + + +class TestPullTarget(unittest.TestCase): + def test_AcceptChoices(self): + pt = PullTarget() + self.assertRaises(NotImplementedError, + pt.AcceptChoices, None, None) + + def test_AcceptPullData(self): + pt = PullTarget() + self.assertRaises(NotImplementedError, + pt.AcceptPullData, None, None, None) + + +class TestDecision(unittest.TestCase): + """ placeholder for future tests """ + pass + + +class TestValidationError(unittest.TestCase): + """ placeholder for future tests """ + pass + + +class TestStructureValidator(unittest.TestCase): + def test_validate_structures(self): + sv = StructureValidator() + self.assertRaises(NotImplementedError, + sv.validate_structures, None, None) + + +class TestGoalValidator(unittest.TestCase): + def test_validate_goals(self): + gv = GoalValidator() + self.assertRaises(NotImplementedError, + gv.validate_goals, None, None) + + +class TestVersion(unittest.TestCase): + """ placeholder for future tests """ + pass + + +class TestClientRunHooks(unittest.TestCase): + """ placeholder for future tests """ + pass + + +class TestFileBacked(unittest.TestCase): + @patch("__builtin__.open") + @patch("Bcfg2.Server.Plugin.FileBacked.Index") + def test_HandleEvent(self, mock_Index, mock_open): + path = "/test" + fb = FileBacked(path) + + def reset(): + mock_Index.reset_mock() + mock_open.reset_mock() + + for evt in ["exists", "changed", "created"]: + reset() + event = Mock() + event.code2str.return_value = evt + fb.HandleEvent(event) + mock_open.assert_called_with(path) + mock_open.return_value.read.assert_any_call() + mock_Index.assert_any_call() + + reset() + event = Mock() + event.code2str.return_value = "endExist" + fb.HandleEvent(event) + self.assertFalse(mock_open.called) + self.assertFalse(mock_Index.called) + -- cgit v1.2.3-1-g7c22 From 35bb03c45a057d1f0f313d129125cc0d1f7c1042 Mon Sep 17 00:00:00 2001 From: "Chris St. Pierre" Date: Thu, 9 Aug 2012 11:51:06 -0400 Subject: move MetadataConsistency/RuntimeError exceptions into Plugin.py so we don't depend on a particular Metadata plugin --- testsuite/Testlib/TestServer/TestPlugin.py | 1 - .../Testlib/TestServer/TestPlugins/TestMetadata.py | 74 +++++++++------------- .../Testlib/TestServer/TestPlugins/TestProbes.py | 1 - 3 files changed, 30 insertions(+), 46 deletions(-) (limited to 'testsuite') diff --git a/testsuite/Testlib/TestServer/TestPlugin.py b/testsuite/Testlib/TestServer/TestPlugin.py index 0d1c0f810..3f25f922d 100644 --- a/testsuite/Testlib/TestServer/TestPlugin.py +++ b/testsuite/Testlib/TestServer/TestPlugin.py @@ -6,7 +6,6 @@ import lxml.etree from mock import Mock, MagicMock, patch from Bcfg2.Server.Plugin import * import Bcfg2.Server -import Bcfg2.Server.Plugins.Metadata datastore = '/' diff --git a/testsuite/Testlib/TestServer/TestPlugins/TestMetadata.py b/testsuite/Testlib/TestServer/TestPlugins/TestMetadata.py index 381bd978e..24e8f9d75 100644 --- a/testsuite/Testlib/TestServer/TestPlugins/TestMetadata.py +++ b/testsuite/Testlib/TestServer/TestPlugins/TestMetadata.py @@ -20,6 +20,7 @@ try: except ImportError: has_django = False + import Bcfg2.Server import Bcfg2.Server.Plugin from Bcfg2.Server.Plugins.Metadata import * @@ -169,15 +170,9 @@ class TestClientVersions(unittest.TestCase): self.assertEqual(v['client2'], "1.2.2") self.assertIsNone(v['client5']) - # test exception on nonexistent client. can't use assertRaises - # for this because assertRaises requires a callable - try: + # test exception on nonexistent client + with self.assertRaises(KeyError): v['clients__getitem'] - assert False - except KeyError: - assert True - except: - assert False def test__len(self): v = ClientVersions() @@ -211,27 +206,16 @@ class TestXMLMetadataConfig(unittest.TestCase): def test_xdata(self): config = self.get_config_object() - # we can't use assertRaises here because xdata is a property - try: + with self.assertRaises(Bcfg2.Server.Plugin.MetadataRuntimeError): config.xdata - assert False - except MetadataRuntimeError: - assert True - except: - assert False config.data = "" self.assertEqual(config.xdata, "") def test_base_xdata(self): config = self.get_config_object() # we can't use assertRaises here because base_xdata is a property - try: + with self.assertRaises(Bcfg2.Server.Plugin.MetadataRuntimeError): config.base_xdata - assert False - except MetadataRuntimeError: - assert True - except: - assert False config.basedata = "" self.assertEqual(config.base_xdata, "") @@ -323,16 +307,16 @@ class TestXMLMetadataConfig(unittest.TestCase): mock_rename.assert_called_with(tmpfile, linkdest) mock_rename.side_effect = OSError - self.assertRaises(MetadataRuntimeError, + self.assertRaises(Bcfg2.Server.Plugin.MetadataRuntimeError, config.write_xml, fpath, self.clients_test_tree) mock_open.return_value.write.side_effect = IOError - self.assertRaises(MetadataRuntimeError, + self.assertRaises(Bcfg2.Server.Plugin.MetadataRuntimeError, config.write_xml, fpath, self.clients_test_tree) mock_unlink.assert_called_with(tmpfile) mock_open.side_effect = IOError - self.assertRaises(MetadataRuntimeError, + self.assertRaises(Bcfg2.Server.Plugin.MetadataRuntimeError, config.write_xml, fpath, self.clients_test_tree) @patch("Bcfg2.Server.Plugins.Metadata.XMLMetadataConfig.load_xml", Mock()) @@ -514,7 +498,7 @@ class TestMetadata(unittest.TestCase): metadata.groups_xml.basedata = copy.copy(metadata.groups_xml.data) metadata.groups_xml.write.reset_mock() - self.assertRaises(MetadataConsistencyError, + self.assertRaises(Bcfg2.Server.Plugin.MetadataConsistencyError, metadata.add_group, "test1", dict()) self.assertFalse(metadata.groups_xml.write.called) @@ -532,7 +516,7 @@ class TestMetadata(unittest.TestCase): self.assertEqual(grp.get("foo"), "bar") self.assertTrue(metadata.groups_xml.write_xml.called) - self.assertRaises(MetadataConsistencyError, + self.assertRaises(Bcfg2.Server.Plugin.MetadataConsistencyError, metadata.update_group, "bogus_group", dict()) @@ -547,7 +531,7 @@ class TestMetadata(unittest.TestCase): self.assertIsNone(grp) self.assertTrue(metadata.groups_xml.write_xml.called) - self.assertRaises(MetadataConsistencyError, + self.assertRaises(Bcfg2.Server.Plugin.MetadataConsistencyError, metadata.remove_group, "bogus_group") @@ -569,7 +553,7 @@ class TestMetadata(unittest.TestCase): metadata.groups_xml.basedata = copy.copy(metadata.groups_xml.data) metadata.groups_xml.write.reset_mock() - self.assertRaises(MetadataConsistencyError, + self.assertRaises(Bcfg2.Server.Plugin.MetadataConsistencyError, metadata.add_bundle, "bundle1") self.assertFalse(metadata.groups_xml.write.called) @@ -585,7 +569,7 @@ class TestMetadata(unittest.TestCase): self.assertIsNone(grp) self.assertTrue(metadata.groups_xml.write_xml.called) - self.assertRaises(MetadataConsistencyError, + self.assertRaises(Bcfg2.Server.Plugin.MetadataConsistencyError, metadata.remove_bundle, "bogus_bundle") @@ -619,7 +603,7 @@ class TestMetadata(unittest.TestCase): metadata.clients_xml.basedata = copy.copy(metadata.clients_xml.data) metadata.clients_xml.write.reset_mock() - self.assertRaises(MetadataConsistencyError, + self.assertRaises(Bcfg2.Server.Plugin.MetadataConsistencyError, metadata.add_client, new1, dict()) self.assertFalse(metadata.clients_xml.write.called) @@ -638,7 +622,7 @@ class TestMetadata(unittest.TestCase): self.assertTrue(metadata.clients_xml.write_xml.called) new = self.get_nonexistent_client(metadata) - self.assertRaises(MetadataConsistencyError, + self.assertRaises(Bcfg2.Server.Plugin.MetadataConsistencyError, metadata.update_client, new, dict()) @@ -755,18 +739,18 @@ class TestMetadata(unittest.TestCase): metadata = self.get_metadata_object() if 'clients.xml' in metadata.states: metadata.states['clients.xml'] = False - self.assertRaises(MetadataRuntimeError, + self.assertRaises(Bcfg2.Server.Plugin.MetadataRuntimeError, metadata.set_profile, None, None, None) self.load_groups_data(metadata=metadata) self.load_clients_data(metadata=metadata) - self.assertRaises(MetadataConsistencyError, + self.assertRaises(Bcfg2.Server.Plugin.MetadataConsistencyError, metadata.set_profile, "client1", "group5", None) - self.assertRaises(MetadataConsistencyError, + self.assertRaises(Bcfg2.Server.Plugin.MetadataConsistencyError, metadata.set_profile, "client1", "group3", None) @@ -820,7 +804,7 @@ class TestMetadata(unittest.TestCase): metadata.session_cache[('1.2.3.3', None)] = (time.time(), 'client3') self.assertEqual(metadata.resolve_client(('1.2.3.3', None)), 'client3') - self.assertRaises(MetadataConsistencyError, + self.assertRaises(Bcfg2.Server.Plugin.MetadataConsistencyError, metadata.resolve_client, ('1.2.3.2', None)) self.assertEqual(metadata.resolve_client(('1.2.3.1', None)), 'client1') @@ -844,7 +828,7 @@ class TestMetadata(unittest.TestCase): mock_gethostbyaddr.reset_mock() mock_gethostbyaddr.return_value = None mock_gethostbyaddr.side_effect = socket.herror - self.assertRaises(MetadataConsistencyError, + self.assertRaises(Bcfg2.Server.Plugin.MetadataConsistencyError, metadata.resolve_client, ('1.2.3.8', None)) mock_gethostbyaddr.assert_called_with('1.2.3.8') @@ -856,7 +840,7 @@ class TestMetadata(unittest.TestCase): metadata = self.get_metadata_object() if 'clients.xml' in metadata.states: metadata.states['clients.xml'] = False - self.assertRaises(MetadataRuntimeError, + self.assertRaises(Bcfg2.Server.Plugin.MetadataRuntimeError, metadata.get_initial_metadata, None) self.load_groups_data(metadata=metadata) @@ -910,7 +894,7 @@ class TestMetadata(unittest.TestCase): # test new client with no default profile metadata.default = None new2 = self.get_nonexistent_client(metadata) - self.assertRaises(MetadataConsistencyError, + self.assertRaises(Bcfg2.Server.Plugin.MetadataConsistencyError, metadata.get_initial_metadata, new2) @patch("Bcfg2.Server.Plugins.Metadata.XMLMetadataConfig.load_xml", Mock()) @@ -1076,7 +1060,8 @@ class TestMetadata(unittest.TestCase): self.assertTrue(metadata.AuthenticateConnection(None, "root", "password1", "1.2.3.8")) - mock_resolve_client.side_effect = MetadataConsistencyError + mock_resolve_client.side_effect = \ + Bcfg2.Server.Plugin.MetadataConsistencyError self.assertFalse(metadata.AuthenticateConnection(None, "root", "password1", "1.2.3.8")) @@ -1219,7 +1204,7 @@ class TestMetadataBase(TestMetadata): metadata = self.get_metadata_object() client_name = self.get_nonexistent_client(metadata) - self.assertRaises(MetadataConsistencyError, + self.assertRaises(Bcfg2.Server.Plugin.MetadataConsistencyError, metadata.remove_client, client_name) @@ -1256,7 +1241,7 @@ class TestMetadata_NoClientsXML(TestMetadataBase): metadata = self.get_metadata_object() if 'clients.xml' in metadata.states: metadata.states['clients.xml'] = False - self.assertRaises(MetadataRuntimeError, + self.assertRaises(Bcfg2.Server.Plugin.MetadataRuntimeError, metadata.get_initial_metadata, None) self.load_groups_data(metadata=metadata) @@ -1300,7 +1285,7 @@ class TestMetadata_NoClientsXML(TestMetadataBase): # test exception on new client with no default profile metadata.default = None new2 = self.get_nonexistent_client(metadata) - self.assertRaises(MetadataConsistencyError, + self.assertRaises(Bcfg2.Server.Plugin.MetadataConsistencyError, metadata.get_initial_metadata, new2) @@ -1342,7 +1327,8 @@ class TestMetadata_NoClientsXML(TestMetadataBase): self.assertTrue(metadata.AuthenticateConnection(None, "root", "password1", "1.2.3.8")) - mock_resolve_client.side_effect = MetadataConsistencyError + mock_resolve_client.side_effect = \ + Bcfg2.Server.Plugin.MetadataConsistencyError self.assertFalse(metadata.AuthenticateConnection(None, "root", "password1", "1.2.3.8")) @@ -1368,7 +1354,7 @@ class TestMetadata_NoClientsXML(TestMetadataBase): mock_gethostbyaddr.reset_mock() mock_gethostbyaddr.return_value = None mock_gethostbyaddr.side_effect = socket.herror - self.assertRaises(MetadataConsistencyError, + self.assertRaises(Bcfg2.Server.Plugin.MetadataConsistencyError, metadata.resolve_client, ('1.2.3.8', None)) mock_gethostbyaddr.assert_called_with('1.2.3.8') diff --git a/testsuite/Testlib/TestServer/TestPlugins/TestProbes.py b/testsuite/Testlib/TestServer/TestPlugins/TestProbes.py index 92e0037f3..ffc6add26 100644 --- a/testsuite/Testlib/TestServer/TestPlugins/TestProbes.py +++ b/testsuite/Testlib/TestServer/TestPlugins/TestProbes.py @@ -408,7 +408,6 @@ text probes._write_data_xml(None) xdata = \ lxml.etree.XML(str(mock_open.return_value.write.call_args[0][0])) - print "rv = %s" % lxml.etree.tostring(xdata) mock_parse.return_value = xdata.getroottree() probes.probedata = dict() probes.cgroups = dict() -- cgit v1.2.3-1-g7c22 From 3fba7f94f1567b91c417477212ea6eba4a456e0a Mon Sep 17 00:00:00 2001 From: "Chris St. Pierre" Date: Thu, 9 Aug 2012 13:56:15 -0400 Subject: DirectoryBacked tests and fixes --- testsuite/Testlib/TestServer/TestPlugin.py | 188 +++++++++++++++++++++++++++++ 1 file changed, 188 insertions(+) (limited to 'testsuite') diff --git a/testsuite/Testlib/TestServer/TestPlugin.py b/testsuite/Testlib/TestServer/TestPlugin.py index 3f25f922d..bf7cd6d09 100644 --- a/testsuite/Testlib/TestServer/TestPlugin.py +++ b/testsuite/Testlib/TestServer/TestPlugin.py @@ -445,3 +445,191 @@ class TestFileBacked(unittest.TestCase): self.assertFalse(mock_open.called) self.assertFalse(mock_Index.called) + +class TestDirectoryBacked(unittest.TestCase): + testpaths = {1: '', + 2: '/foo', + 3: '/foo/bar', + 4: '/foo/bar/baz', + 5: 'quux', + 6: 'xyzzy/', + 7: 'xyzzy/plugh/'} + + @patch("Bcfg2.Server.Plugin.DirectoryBacked.add_directory_monitor", Mock()) + def get_obj(self, fam=None): + if fam is None: + fam = Mock() + return DirectoryBacked(datastore, fam) + + @patch("Bcfg2.Server.Plugin.DirectoryBacked.add_directory_monitor") + def test__init(self, mock_add_monitor): + db = DirectoryBacked(datastore, Mock()) + mock_add_monitor.assert_called_with('') + + def test__getitem(self): + db = self.get_obj() + db.entries.update(dict(a=1, b=2, c=3)) + self.assertEqual(db['a'], 1) + self.assertEqual(db['b'], 2) + with self.assertRaises(KeyError): + db['d'] + + def test__iter(self): + db = self.get_obj() + db.entries.update(dict(a=1, b=2, c=3)) + self.assertEqual([i for i in db], + [i for i in db.entries.items()]) + + @patch("os.path.isdir") + def test_add_directory_monitor(self, mock_isdir): + fam = Mock() + fam.rv = 0 + db = self.get_obj(fam=fam) + + def reset(): + fam.rv += 1 + fam.AddMonitor.return_value = fam.rv + fam.reset_mock() + mock_isdir.reset_mock() + + mock_isdir.return_value = True + for path in self.testpaths.values(): + reset() + db.add_directory_monitor(path) + fam.AddMonitor.assert_called_with(os.path.join(datastore, + path), + db) + self.assertIn(fam.rv, db.handles) + self.assertEqual(db.handles[fam.rv], path) + + reset() + # test duplicate adds + for path in self.testpaths.values(): + reset() + db.add_directory_monitor(path) + self.assertFalse(fam.AddMonitor.called) + + reset() + mock_isdir.return_value = False + db.add_directory_monitor('bogus') + self.assertFalse(fam.AddMonitor.called) + self.assertNotIn(fam.rv, db.handles) + + def test_add_entry(self): + fam = Mock() + db = self.get_obj(fam=fam) + class MockChild(Mock): + def __init__(self, path, fam, **kwargs): + Mock.__init__(self, **kwargs) + self.path = path + self.fam = fam + self.HandleEvent = Mock() + db.__child__ = MockChild + + for path in self.testpaths.values(): + event = Mock() + db.add_entry(path, event) + self.assertIn(path, db.entries) + self.assertEqual(db.entries[path].path, + os.path.join(datastore, path)) + self.assertEqual(db.entries[path].fam, fam) + db.entries[path].HandleEvent.assert_called_with(event) + + @patch("os.path.isdir") + @patch("Bcfg2.Server.Plugin.DirectoryBacked.add_entry") + @patch("Bcfg2.Server.Plugin.DirectoryBacked.add_directory_monitor") + def test_HandleEvent(self, mock_add_monitor, mock_add_entry, mock_isdir): + fam = Mock() + db = self.get_obj(fam=fam) + # a path with a leading / should never get into + # DirectoryBacked.handles, so strip that test case + for rid, path in self.testpaths.items(): + path = path.lstrip('/') + db.handles[rid] = path + + def reset(): + fam.reset_mock() + mock_isdir.reset_mock() + mock_add_entry.reset_mock() + mock_add_monitor.reset_mock() + + def get_event(filename, action, requestID): + event = Mock() + event.code2str.return_value = action + event.filename = filename + event.requestID = requestID + return event + + # test that events on paths that aren't handled fail properly + reset() + event = get_event('/foo', 'created', max(self.testpaths.keys()) + 1) + db.HandleEvent(event) + self.assertFalse(mock_add_monitor.called) + self.assertFalse(mock_add_entry.called) + + for req_id, path in self.testpaths.items(): + # a path with a leading / should never get into + # DirectoryBacked.handles, so strip that test case + path = path.lstrip('/') + basepath = os.path.join(datastore, path) + for fname in ['foo', 'bar/baz.txt', 'plugh.py']: + relpath = os.path.join(path, fname) + abspath = os.path.join(basepath, fname) + + # test endExist does nothing + reset() + event = get_event(fname, 'endExist', req_id) + db.HandleEvent(event) + self.assertFalse(mock_add_monitor.called) + self.assertFalse(mock_add_entry.called) + + mock_isdir.return_value = True + for evt in ["created", "exists", "changed"]: + # test that creating or changing a directory works + reset() + event = get_event(fname, evt, req_id) + db.HandleEvent(event) + mock_add_monitor.assert_called_with(relpath) + self.assertFalse(mock_add_entry.called) + + mock_isdir.return_value = False + for evt in ["created", "exists"]: + # test that creating a file works + reset() + event = get_event(fname, evt, req_id) + db.HandleEvent(event) + mock_add_entry.assert_called_with(relpath, event) + self.assertFalse(mock_add_monitor.called) + db.entries[relpath] = Mock() + + # test that changing a file that already exists works + reset() + event = get_event(fname, "changed", req_id) + db.HandleEvent(event) + db.entries[relpath].HandleEvent.assert_called_with(event) + self.assertFalse(mock_add_monitor.called) + self.assertFalse(mock_add_entry.called) + + # test that deleting an entry works + reset() + event = get_event(fname, "deleted", req_id) + db.HandleEvent(event) + self.assertNotIn(relpath, db.entries) + + # test that changing a file that doesn't exist works + reset() + event = get_event(fname, "changed", req_id) + db.HandleEvent(event) + mock_add_entry.assert_called_with(relpath, event) + self.assertFalse(mock_add_monitor.called) + db.entries[relpath] = Mock() + + # test that deleting a directory works. this is a little + # strange because the _parent_ directory has to handle the + # deletion + reset() + event = get_event('quux', "deleted", 1) + db.HandleEvent(event) + for key in db.entries.keys(): + self.assertFalse(key.startswith('quux')) + -- cgit v1.2.3-1-g7c22 From baad4ec996c599874364025590d9149f578ef99d Mon Sep 17 00:00:00 2001 From: "Chris St. Pierre" Date: Thu, 9 Aug 2012 16:05:33 -0400 Subject: tests and fixes for XMLFileBacked --- testsuite/Testlib/TestServer/TestPlugin.py | 189 +++++++++++++++++++++++++++++ 1 file changed, 189 insertions(+) (limited to 'testsuite') diff --git a/testsuite/Testlib/TestServer/TestPlugin.py b/testsuite/Testlib/TestServer/TestPlugin.py index bf7cd6d09..ff59c48e2 100644 --- a/testsuite/Testlib/TestServer/TestPlugin.py +++ b/testsuite/Testlib/TestServer/TestPlugin.py @@ -15,6 +15,9 @@ def call(*args, **kwargs): calls """ return (args, kwargs) +class FakeElementTree(lxml.etree._ElementTree): + xinclude = Mock() + class TestFunctions(unittest.TestCase): def test_bind_info(self): @@ -633,3 +636,189 @@ class TestDirectoryBacked(unittest.TestCase): for key in db.entries.keys(): self.assertFalse(key.startswith('quux')) + +class TestXMLFileBacked(unittest.TestCase): + def test__init(self): + fam = Mock() + fname = "/test" + xfb = XMLFileBacked(fname) + self.assertIsNone(xfb.fam) + + xfb = XMLFileBacked(fname, fam=fam) + self.assertFalse(fam.AddMonitor.called) + + fam.reset_mock() + xfb = XMLFileBacked(fname, fam=fam, should_monitor=True) + fam.AddMonitor.assert_called_with(fname, xfb) + + @patch("os.path.exists") + @patch("lxml.etree.parse") + @patch("Bcfg2.Server.Plugin.XMLFileBacked.add_monitor") + def test_follow_xincludes(self, mock_add_monitor, mock_parse, mock_exists): + fname = "/test/test1.xml" + xfb = XMLFileBacked(fname) + + def reset(): + mock_add_monitor.reset_mock() + mock_parse.reset_mock() + mock_exists.reset_mock() + xfb.extras = [] + + mock_exists.return_value = True + xdata = dict() + mock_parse.side_effect = lambda p: xdata[p] + + # basic functionality + xdata['/test/test2.xml'] = lxml.etree.Element("Test").getroottree() + xfb._follow_xincludes(xdata=xdata['/test/test2.xml']) + self.assertFalse(mock_add_monitor.called) + + reset() + xfb.xdata = xdata['/test/test2.xml'].getroot() + xfb._follow_xincludes() + self.assertFalse(mock_add_monitor.called) + xfb.xdata = None + + reset() + xfb._follow_xincludes(fname="/test/test2.xml") + self.assertFalse(mock_add_monitor.called) + + # test one level of xinclude + xdata[fname] = lxml.etree.Element("Test").getroottree() + lxml.etree.SubElement(xdata[fname].getroot(), + Bcfg2.Server.XI_NAMESPACE + "include", + href="/test/test2.xml") + reset() + xfb._follow_xincludes(fname=fname) + mock_add_monitor.assert_called_with("/test/test2.xml") + self.assertItemsEqual(mock_parse.call_args_list, + [call(f) for f in xdata.keys()]) + mock_exists.assert_called_with("/test/test2.xml") + + reset() + xfb._follow_xincludes(xdata=xdata[fname]) + mock_add_monitor.assert_called_with("/test/test2.xml") + self.assertItemsEqual(mock_parse.call_args_list, + [call(f) for f in xdata.keys() + if f != fname]) + mock_exists.assert_called_with("/test/test2.xml") + + # test two-deep level of xinclude, with some files in another + # directory + xdata["/test/test3.xml"] = \ + lxml.etree.Element("Test").getroottree() + lxml.etree.SubElement(xdata["/test/test3.xml"].getroot(), + Bcfg2.Server.XI_NAMESPACE + "include", + href="/test/test_dir/test4.xml") + xdata["/test/test_dir/test4.xml"] = \ + lxml.etree.Element("Test").getroottree() + lxml.etree.SubElement(xdata["/test/test_dir/test4.xml"].getroot(), + Bcfg2.Server.XI_NAMESPACE + "include", + href="/test/test_dir/test5.xml") + xdata['/test/test_dir/test5.xml'] = \ + lxml.etree.Element("Test").getroottree() + xdata['/test/test_dir/test6.xml'] = \ + lxml.etree.Element("Test").getroottree() + # relative includes + lxml.etree.SubElement(xdata[fname].getroot(), + Bcfg2.Server.XI_NAMESPACE + "include", + href="test3.xml") + lxml.etree.SubElement(xdata["/test/test3.xml"].getroot(), + Bcfg2.Server.XI_NAMESPACE + "include", + href="test_dir/test6.xml") + + reset() + xfb._follow_xincludes(fname=fname) + self.assertItemsEqual(mock_add_monitor.call_args_list, + [call(f) for f in xdata.keys() if f != fname]) + self.assertItemsEqual(mock_parse.call_args_list, + [call(f) for f in xdata.keys()]) + self.assertItemsEqual(mock_exists.call_args_list, + [call(f) for f in xdata.keys() if f != fname]) + + reset() + xfb._follow_xincludes(xdata=xdata[fname]) + self.assertItemsEqual(mock_add_monitor.call_args_list, + [call(f) for f in xdata.keys() if f != fname]) + self.assertItemsEqual(mock_parse.call_args_list, + [call(f) for f in xdata.keys() if f != fname]) + self.assertItemsEqual(mock_exists.call_args_list, + [call(f) for f in xdata.keys() if f != fname]) + + @patch("lxml.etree._ElementTree", FakeElementTree) + @patch("Bcfg2.Server.Plugin.XMLFileBacked._follow_xincludes") + def test_Index(self, mock_follow): + fname = "/test/test1.xml" + xfb = XMLFileBacked(fname) + + def reset(): + mock_follow.reset_mock() + FakeElementTree.xinclude.reset_mock() + xfb.extras = [] + xfb.xdata = None + + # syntax error + xfb.data = "<" + self.assertRaises(PluginInitError, xfb.Index) + + # no xinclude + reset() + xdata = lxml.etree.Element("Test", name="test") + children = [lxml.etree.SubElement(xdata, "Foo"), + lxml.etree.SubElement(xdata, "Bar", name="bar")] + xfb.data = lxml.etree.tostring(xdata) + xfb.Index() + mock_follow.assert_any_call() + self.assertEqual(xfb.xdata.base, fname) + self.assertItemsEqual([lxml.etree.tostring(e) for e in xfb.entries], + [lxml.etree.tostring(e) for e in children]) + + # with xincludes + reset() + mock_follow.side_effect = \ + lambda: xfb.extras.extend(["/test/test2.xml", + "/test/test_dir/test3.xml"]) + children.extend([ + lxml.etree.SubElement(xdata, + Bcfg2.Server.XI_NAMESPACE + "include", + href="/test/test2.xml"), + lxml.etree.SubElement(xdata, + Bcfg2.Server.XI_NAMESPACE + "include", + href="/test/test_dir/test3.xml")]) + test2 = lxml.etree.Element("Test", name="test2") + lxml.etree.SubElement(test2, "Baz") + test3 = lxml.etree.Element("Test", name="test3") + replacements = {"/test/test2.xml": test2, + "/test/test_dir/test3.xml": test3} + def xinclude(): + for el in xfb.xdata.findall('//%sinclude' % + Bcfg2.Server.XI_NAMESPACE): + xfb.xdata.replace(el, replacements[el.get("href")]) + FakeElementTree.xinclude.side_effect = xinclude + + xfb.data = lxml.etree.tostring(xdata) + xfb.Index() + mock_follow.assert_any_call() + FakeElementTree.xinclude.assert_any_call + self.assertEqual(xfb.xdata.base, fname) + self.assertItemsEqual([lxml.etree.tostring(e) for e in xfb.entries], + [lxml.etree.tostring(e) for e in children]) + + def test_add_monitor(self): + fname = "/test/test1.xml" + xfb = XMLFileBacked(fname) + xfb.add_monitor("/test/test2.xml") + self.assertIn("/test/test2.xml", xfb.extras) + + fam = Mock() + xfb = XMLFileBacked(fname, fam=fam) + fam.reset_mock() + xfb.add_monitor("/test/test3.xml") + self.assertFalse(fam.AddMonitor.called) + self.assertIn("/test/test3.xml", xfb.extras) + + fam.reset_mock() + xfb = XMLFileBacked(fname, fam=fam, should_monitor=True) + xfb.add_monitor("/test/test4.xml") + fam.AddMonitor.assert_called_with("/test/test4.xml", xfb) + self.assertIn("/test/test4.xml", xfb.extras) -- cgit v1.2.3-1-g7c22 From d5ed9b3fd3a7f291841fef12e5992706f5d317ca Mon Sep 17 00:00:00 2001 From: "Chris St. Pierre" Date: Fri, 10 Aug 2012 11:36:27 -0400 Subject: StructFile tests and fixes --- testsuite/Testlib/TestServer/TestPlugin.py | 231 ++++++++++++++++++++++++++++- 1 file changed, 226 insertions(+), 5 deletions(-) (limited to 'testsuite') diff --git a/testsuite/Testlib/TestServer/TestPlugin.py b/testsuite/Testlib/TestServer/TestPlugin.py index ff59c48e2..6a59ad190 100644 --- a/testsuite/Testlib/TestServer/TestPlugin.py +++ b/testsuite/Testlib/TestServer/TestPlugin.py @@ -111,7 +111,7 @@ class TestDebuggable(unittest.TestCase): self.assertTrue(d.logger.error.called) -class TestPlugin(unittest.TestCase): +class TestPlugin(TestDebuggable): def test__init(self): core = Mock() p = Plugin(core, datastore) @@ -125,7 +125,7 @@ class TestPlugin(unittest.TestCase): mock_makedirs.assert_called_with(os.path.join(datastore, Plugin.name)) -class TestDatabaseBacked(unittest.TestCase): +class TestDatabaseBacked(TestPlugin): @unittest.skipUnless(has_django, "Django not found") def test__use_db(self): core = Mock() @@ -196,12 +196,12 @@ class TestProbing(unittest.TestCase): pass -class TestStatistics(unittest.TestCase): +class TestStatistics(TestPlugin): """ placeholder """ pass -class TestThreadedStatistics(unittest.TestCase): +class TestThreadedStatistics(TestStatistics): data = [("foo.example.com", ""), ("bar.example.com", "")] @@ -637,7 +637,7 @@ class TestDirectoryBacked(unittest.TestCase): self.assertFalse(key.startswith('quux')) -class TestXMLFileBacked(unittest.TestCase): +class TestXMLFileBacked(TestFileBacked): def test__init(self): fam = Mock() fname = "/test" @@ -822,3 +822,224 @@ class TestXMLFileBacked(unittest.TestCase): xfb.add_monitor("/test/test4.xml") fam.AddMonitor.assert_called_with("/test/test4.xml", xfb) self.assertIn("/test/test4.xml", xfb.extras) + +class TestStructFile(TestXMLFileBacked): + def _get_test_data(self): + """ build a very complex set of test data """ + # top-level group and client elements + groups = dict() + # group and client elements that are descendents of other group or + # client elements + subgroups = dict() + # children of elements in `groups' that should be included in + # match results + children = dict() + # children of elements in `subgroups' that should be included in + # match results + subchildren = dict() + # top-level tags that are not group elements + standalone = [] + xdata = lxml.etree.Element("Test", name="test") + groups[0] = lxml.etree.SubElement(xdata, "Group", name="group1", + include="true") + children[0] = [lxml.etree.SubElement(groups[0], "Child", name="c1"), + lxml.etree.SubElement(groups[0], "Child", name="c2")] + subgroups[0] = [lxml.etree.SubElement(groups[0], "Group", + name="subgroup1", include="true"), + lxml.etree.SubElement(groups[0], + "Client", name="client1", + include="false")] + subchildren[0] = \ + [lxml.etree.SubElement(subgroups[0][0], "Child", name="sc1"), + lxml.etree.SubElement(subgroups[0][0], "Child", name="sc2", + attr="some attr"), + lxml.etree.SubElement(subgroups[0][0], "Child", name="sc3")] + lxml.etree.SubElement(subchildren[0][-1], "SubChild", name="subchild") + lxml.etree.SubElement(subgroups[0][1], "Child", name="sc4") + + groups[1] = lxml.etree.SubElement(xdata, "Group", name="group2", + include="false") + children[1] = [] + subgroups[1] = [] + subchildren[1] = [] + lxml.etree.SubElement(groups[1], "Child", name="c3") + lxml.etree.SubElement(groups[1], "Child", name="c4") + + standalone.append(lxml.etree.SubElement(xdata, "Standalone", name="s1")) + + groups[2] = lxml.etree.SubElement(xdata, "Client", name="client2", + include="false") + children[2] = [] + subgroups[2] = [] + subchildren[2] = [] + lxml.etree.SubElement(groups[2], "Child", name="c5") + lxml.etree.SubElement(groups[2], "Child", name="c6") + + standalone.append(lxml.etree.SubElement(xdata, "Standalone", name="s2", + attr="some attr")) + + groups[3] = lxml.etree.SubElement(xdata, "Client", name="client3", + include="true") + children[3] = [lxml.etree.SubElement(groups[3], "Child", name="c7", + attr="some_attr"), + lxml.etree.SubElement(groups[3], "Child", name="c8")] + subgroups[3] = [] + subchildren[3] = [] + lxml.etree.SubElement(children[3][-1], "SubChild", name="subchild") + + standalone.append(lxml.etree.SubElement(xdata, "Standalone", name="s3")) + lxml.etree.SubElement(standalone[-1], "SubStandalone", name="sub1") + + children[4] = standalone + return (xdata, groups, subgroups, children, subchildren, standalone) + + def assertXMLEqual(self, el1, el2, msg=None): + self.assertEqual(el1.tag, el2.tag, msg=msg) + self.assertEqual(el1.text, el2.text, msg=msg) + self.assertItemsEqual(el1.attrib, el2.attrib, msg=msg) + self.assertEqual(len(el1.getchildren()), + len(el2.getchildren())) + for child1 in el1.getchildren(): + cname = child1.get("name") + self.assertIsNotNone(cname, + msg="Element %s has no 'name' attribute" % + child1.tag) + children2 = el2.xpath("*[@name='%s']" % cname) + self.assertEqual(len(children2), 1, + msg="More than one element named %s" % cname) + self.assertXMLEqual(child1, children2[0], msg=msg) + + def test_include_element(self): + sf = StructFile("/test/test.xml") + metadata = Mock() + metadata.groups = ["group1", "group2"] + metadata.hostname = "foo.example.com" + + inc = lambda tag, **attrs: \ + sf._include_element(lxml.etree.Element(tag, **attrs), metadata) + + self.assertFalse(sf._include_element(lxml.etree.Comment("test"), + metadata)) + + self.assertFalse(inc("Group", name="group3")) + self.assertFalse(inc("Group", name="group2", negate="true")) + self.assertFalse(inc("Group", name="group2", negate="tRuE")) + self.assertTrue(inc("Group", name="group2")) + self.assertTrue(inc("Group", name="group2", negate="false")) + self.assertTrue(inc("Group", name="group2", negate="faLSe")) + self.assertTrue(inc("Group", name="group3", negate="true")) + self.assertTrue(inc("Group", name="group3", negate="tRUe")) + + self.assertFalse(inc("Client", name="bogus.example.com")) + self.assertFalse(inc("Client", name="foo.example.com", negate="true")) + self.assertFalse(inc("Client", name="foo.example.com", negate="tRuE")) + self.assertTrue(inc("Client", name="foo.example.com")) + self.assertTrue(inc("Client", name="foo.example.com", negate="false")) + self.assertTrue(inc("Client", name="foo.example.com", negate="faLSe")) + self.assertTrue(inc("Client", name="bogus.example.com", negate="true")) + self.assertTrue(inc("Client", name="bogus.example.com", negate="tRUe")) + + self.assertTrue(inc("Other")) + + @patch("Bcfg2.Server.Plugin.StructFile._include_element") + def test__match(self, mock_include): + sf = StructFile("/test/test.xml") + metadata = Mock() + + (xdata, groups, subgroups, children, subchildren, standalone) = \ + self._get_test_data() + + mock_include.side_effect = \ + lambda x, _: (x.tag not in ['Client', 'Group'] or + x.get("include") == "true") + + for i, group in groups.items(): + actual = sf._match(group, metadata) + expected = children[i] + subchildren[i] + self.assertEqual(len(actual), len(expected)) + # easiest way to compare the values is actually to make + # them into an XML document and let assertXMLEqual compare + # them + xactual = lxml.etree.Element("Container") + xactual.extend(actual) + xexpected = lxml.etree.Element("Container") + xexpected.extend(expected) + self.assertXMLEqual(xactual, xexpected) + + for el in standalone: + self.assertXMLEqual(el, sf._match(el, metadata)[0]) + + @patch("Bcfg2.Server.Plugin.StructFile._match") + def test_Match(self, mock_match): + sf = StructFile("/test/test.xml") + metadata = Mock() + + (xdata, groups, subgroups, children, subchildren, standalone) = \ + self._get_test_data() + sf.entries.extend(copy.deepcopy(xdata).getchildren()) + + def match_rv(el, _): + if el.tag not in ['Client', 'Group']: + return [el] + elif x.get("include") == "true": + return el.getchildren() + else: + return [] + mock_match.side_effect = match_rv + actual = sf.Match(metadata) + expected = reduce(lambda x, y: x + y, + children.values() + subgroups.values()) + self.assertEqual(len(actual), len(expected)) + # easiest way to compare the values is actually to make + # them into an XML document and let assertXMLEqual compare + # them + xactual = lxml.etree.Element("Container") + xactual.extend(actual) + xexpected = lxml.etree.Element("Container") + xexpected.extend(expected) + self.assertXMLEqual(xactual, xexpected) + + @patch("Bcfg2.Server.Plugin.StructFile._include_element") + def test__xml_match(self, mock_include): + sf = StructFile("/test/test.xml") + metadata = Mock() + + (xdata, groups, subgroups, children, subchildren, standalone) = \ + self._get_test_data() + + mock_include.side_effect = \ + lambda x, _: (x.tag not in ['Client', 'Group'] or + x.get("include") == "true") + + actual = copy.deepcopy(xdata) + for el in actual.getchildren(): + sf._xml_match(el, metadata) + expected = lxml.etree.Element(xdata.tag, **xdata.attrib) + expected.text = xdata.text + expected.extend(reduce(lambda x, y: x + y, + children.values() + subchildren.values())) + expected.extend(standalone) + self.assertXMLEqual(actual, expected) + + @patch("Bcfg2.Server.Plugin.StructFile._xml_match") + def test_Match(self, mock_xml_match): + sf = StructFile("/test/test.xml") + metadata = Mock() + + (sf.xdata, groups, subgroups, children, subchildren, standalone) = \ + self._get_test_data() + + sf.XMLMatch(metadata) + actual = [] + for call in mock_xml_match.call_args_list: + actual.append(call[0][0]) + self.assertEqual(call[0][1], metadata) + expected = groups.values() + standalone + # easiest way to compare the values is actually to make + # them into an XML document and let assertXMLEqual compare + # them + xactual = lxml.etree.Element("Container") + xactual.extend(actual) + xexpected = lxml.etree.Element("Container") + xexpected.extend(expected) + self.assertXMLEqual(xactual, xexpected) -- cgit v1.2.3-1-g7c22 From a9a36c9c6802ce70403bfb8b20b076a17d02f99a Mon Sep 17 00:00:00 2001 From: "Chris St. Pierre" Date: Fri, 10 Aug 2012 11:47:50 -0400 Subject: made plugin tests inherit from plugin interface tests --- testsuite/Testlib/TestServer/TestPlugin.py | 5 +++++ .../Testlib/TestServer/TestPlugins/TestMetadata.py | 18 ++++++++++-------- testsuite/Testlib/TestServer/TestPlugins/TestProbes.py | 6 ++++-- testsuite/Testlib/TestServer/TestPlugins/__init__.py | 0 testsuite/Testlib/TestServer/__init__.py | 0 testsuite/Testlib/__init__.py | 0 6 files changed, 19 insertions(+), 10 deletions(-) create mode 100644 testsuite/Testlib/TestServer/TestPlugins/__init__.py create mode 100644 testsuite/Testlib/TestServer/__init__.py create mode 100644 testsuite/Testlib/__init__.py (limited to 'testsuite') diff --git a/testsuite/Testlib/TestServer/TestPlugin.py b/testsuite/Testlib/TestServer/TestPlugin.py index 6a59ad190..a23ef2473 100644 --- a/testsuite/Testlib/TestServer/TestPlugin.py +++ b/testsuite/Testlib/TestServer/TestPlugin.py @@ -1043,3 +1043,8 @@ class TestStructFile(TestXMLFileBacked): xexpected = lxml.etree.Element("Container") xexpected.extend(expected) self.assertXMLEqual(xactual, xexpected) + + + +class TestEntrySet(unittest.TestCase): + pass diff --git a/testsuite/Testlib/TestServer/TestPlugins/TestMetadata.py b/testsuite/Testlib/TestServer/TestPlugins/TestMetadata.py index 24e8f9d75..6926d6eef 100644 --- a/testsuite/Testlib/TestServer/TestPlugins/TestMetadata.py +++ b/testsuite/Testlib/TestServer/TestPlugins/TestMetadata.py @@ -20,10 +20,11 @@ try: except ImportError: has_django = False - import Bcfg2.Server import Bcfg2.Server.Plugin from Bcfg2.Server.Plugins.Metadata import * +from ..TestPlugin import TestXMLFileBacked, TestMetadata, TestStatistics, \ + TestDatabaseBacked XI_NAMESPACE = "http://www.w3.org/2001/XInclude" XI = "{%s}" % XI_NAMESPACE @@ -194,7 +195,7 @@ class TestClientVersions(unittest.TestCase): self.assertIsNone(v[new]) -class TestXMLMetadataConfig(unittest.TestCase): +class TestXMLMetadataConfig(TestXMLFileBacked): groups_test_tree = groups_test_tree clients_test_tree = clients_test_tree @@ -227,14 +228,14 @@ class TestXMLMetadataConfig(unittest.TestCase): fpath = os.path.join(self.metadata.data, fname) config.extras = [] - config.add_monitor(fpath, fname) + config.add_monitor(fpath) self.assertFalse(core.fam.AddMonitor.called) - self.assertEqual(config.extras, [fname]) + self.assertEqual(config.extras, [fpath]) config = self.get_config_object(core=core, watch_clients=True) - config.add_monitor(fpath, fname) + config.add_monitor(fpath) core.fam.AddMonitor.assert_called_with(fpath, config.metadata) - self.assertItemsEqual(config.extras, [fname]) + self.assertItemsEqual(config.extras, [fpath]) @patch("Bcfg2.Server.Plugins.Metadata.XMLMetadataConfig.add_monitor") @patch("lxml.etree.parse") @@ -333,7 +334,8 @@ class TestXMLMetadataConfig(unittest.TestCase): self.assertEqual(config.find_xml_for_xpath("//boguselement"), dict()) - config.extras = ["foo.xml", "bar.xml", "clients.xml"] + config.extras = [os.path.join(self.metadata.data, p) + for p in ["foo.xml", "bar.xml", "clients.xml"]] def parse_side_effect(fname, parser=Bcfg2.Server.XMLParser): if fname == os.path.join(self.metadata.data, "clients.xml"): @@ -367,7 +369,7 @@ class TestClientMetadata(unittest.TestCase): self.assertFalse(cm.inGroup("group3")) -class TestMetadata(unittest.TestCase): +class TestMetadata(TestMetadata, TestStatistics, TestDatabaseBacked): groups_test_tree = groups_test_tree clients_test_tree = clients_test_tree use_db = False diff --git a/testsuite/Testlib/TestServer/TestPlugins/TestProbes.py b/testsuite/Testlib/TestServer/TestPlugins/TestProbes.py index ffc6add26..fc901af68 100644 --- a/testsuite/Testlib/TestServer/TestPlugins/TestProbes.py +++ b/testsuite/Testlib/TestServer/TestPlugins/TestProbes.py @@ -21,6 +21,8 @@ except ImportError: import Bcfg2.Server import Bcfg2.Server.Plugin from Bcfg2.Server.Plugins.Probes import * +from ..TestPlugin import TestEntrySet, TestProbing, TestConnector, \ + TestDatabaseBacked datastore = "/" @@ -100,7 +102,7 @@ class TestProbeData(unittest.TestCase): self.assertItemsEqual(test_data, data.yaml) -class TestProbeSet(unittest.TestCase): +class TestProbeSet(TestEntrySet): def get_probeset_object(self, fam=None): if fam is None: fam = Mock() @@ -196,7 +198,7 @@ group-specific""" assert False, "Strange probe found in get_probe_data() return" -class TestProbes(unittest.TestCase): +class TestProbes(TestProbing, TestConnector, TestDatabaseBacked): def get_test_probedata(self): test_xdata = lxml.etree.Element("test") lxml.etree.SubElement(test_xdata, "test", foo="foo") diff --git a/testsuite/Testlib/TestServer/TestPlugins/__init__.py b/testsuite/Testlib/TestServer/TestPlugins/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/testsuite/Testlib/TestServer/__init__.py b/testsuite/Testlib/TestServer/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/testsuite/Testlib/__init__.py b/testsuite/Testlib/__init__.py new file mode 100644 index 000000000..e69de29bb -- cgit v1.2.3-1-g7c22 From ffde9c4783902d6904e41c3d5aa620d3f47b1117 Mon Sep 17 00:00:00 2001 From: "Chris St. Pierre" Date: Mon, 13 Aug 2012 14:27:27 -0400 Subject: added unit tests for INode, InfoNode --- testsuite/Testlib/TestServer/TestPlugin.py | 343 +++++++++++++++++++++++++---- 1 file changed, 306 insertions(+), 37 deletions(-) (limited to 'testsuite') diff --git a/testsuite/Testlib/TestServer/TestPlugin.py b/testsuite/Testlib/TestServer/TestPlugin.py index a23ef2473..0ce32eb91 100644 --- a/testsuite/Testlib/TestServer/TestPlugin.py +++ b/testsuite/Testlib/TestServer/TestPlugin.py @@ -15,11 +15,29 @@ def call(*args, **kwargs): calls """ return (args, kwargs) +class Bcfg2TestCase(unittest.TestCase): + def assertXMLEqual(self, el1, el2, msg=None): + self.assertEqual(el1.tag, el2.tag, msg=msg) + self.assertEqual(el1.text, el2.text, msg=msg) + self.assertItemsEqual(el1.attrib, el2.attrib, msg=msg) + self.assertEqual(len(el1.getchildren()), + len(el2.getchildren())) + for child1 in el1.getchildren(): + cname = child1.get("name") + self.assertIsNotNone(cname, + msg="Element %s has no 'name' attribute" % + child1.tag) + children2 = el2.xpath("*[@name='%s']" % cname) + self.assertEqual(len(children2), 1, + msg="More than one element named %s" % cname) + self.assertXMLEqual(child1, children2[0], msg=msg) + + class FakeElementTree(lxml.etree._ElementTree): xinclude = Mock() -class TestFunctions(unittest.TestCase): +class TestFunctions(Bcfg2TestCase): def test_bind_info(self): entry = lxml.etree.Element("Path", name="/test") metadata = Mock() @@ -62,17 +80,17 @@ class TestFunctions(unittest.TestCase): name="/test")) -class TestPluginInitError(unittest.TestCase): +class TestPluginInitError(Bcfg2TestCase): """ placeholder for future tests """ pass -class TestPluginExecutionError(unittest.TestCase): +class TestPluginExecutionError(Bcfg2TestCase): """ placeholder for future tests """ pass -class TestDebuggable(unittest.TestCase): +class TestDebuggable(Bcfg2TestCase): def test__init(self): d = Debuggable() self.assertIsInstance(d.logger, logging.Logger) @@ -150,26 +168,26 @@ class TestDatabaseBacked(TestPlugin): Bcfg2.Server.Plugin.has_django = True -class TestPluginDatabaseModel(unittest.TestCase): +class TestPluginDatabaseModel(Bcfg2TestCase): """ placeholder for future tests """ pass -class TestGenerator(unittest.TestCase): +class TestGenerator(Bcfg2TestCase): def test_HandleEntry(self): g = Generator() self.assertRaises(NotImplementedError, g.HandleEntry, None, None) -class TestStructure(unittest.TestCase): +class TestStructure(Bcfg2TestCase): def test_BuildStructures(self): s = Structure() self.assertRaises(NotImplementedError, s.BuildStructures, None) -class TestMetadata(unittest.TestCase): +class TestMetadata(Bcfg2TestCase): def test_get_initial_metadata(self): m = Metadata() self.assertRaises(NotImplementedError, @@ -186,12 +204,12 @@ class TestMetadata(unittest.TestCase): m.merge_additional_groups, None, None) -class TestConnector(unittest.TestCase): +class TestConnector(Bcfg2TestCase): """ placeholder """ pass -class TestProbing(unittest.TestCase): +class TestProbing(Bcfg2TestCase): """ placeholder """ pass @@ -368,14 +386,14 @@ class TestThreadedStatistics(TestStatistics): ts.process_statistics(*self.data[0]) -class TestPullSource(unittest.TestCase): +class TestPullSource(Bcfg2TestCase): def test_GetCurrentEntry(self): ps = PullSource() self.assertRaises(NotImplementedError, ps.GetCurrentEntry, None, None, None) -class TestPullTarget(unittest.TestCase): +class TestPullTarget(Bcfg2TestCase): def test_AcceptChoices(self): pt = PullTarget() self.assertRaises(NotImplementedError, @@ -387,41 +405,41 @@ class TestPullTarget(unittest.TestCase): pt.AcceptPullData, None, None, None) -class TestDecision(unittest.TestCase): +class TestDecision(Bcfg2TestCase): """ placeholder for future tests """ pass -class TestValidationError(unittest.TestCase): +class TestValidationError(Bcfg2TestCase): """ placeholder for future tests """ pass -class TestStructureValidator(unittest.TestCase): +class TestStructureValidator(Bcfg2TestCase): def test_validate_structures(self): sv = StructureValidator() self.assertRaises(NotImplementedError, sv.validate_structures, None, None) -class TestGoalValidator(unittest.TestCase): +class TestGoalValidator(Bcfg2TestCase): def test_validate_goals(self): gv = GoalValidator() self.assertRaises(NotImplementedError, gv.validate_goals, None, None) -class TestVersion(unittest.TestCase): +class TestVersion(Bcfg2TestCase): """ placeholder for future tests """ pass -class TestClientRunHooks(unittest.TestCase): +class TestClientRunHooks(Bcfg2TestCase): """ placeholder for future tests """ pass -class TestFileBacked(unittest.TestCase): +class TestFileBacked(Bcfg2TestCase): @patch("__builtin__.open") @patch("Bcfg2.Server.Plugin.FileBacked.Index") def test_HandleEvent(self, mock_Index, mock_open): @@ -449,7 +467,7 @@ class TestFileBacked(unittest.TestCase): self.assertFalse(mock_Index.called) -class TestDirectoryBacked(unittest.TestCase): +class TestDirectoryBacked(Bcfg2TestCase): testpaths = {1: '', 2: '/foo', 3: '/foo/bar', @@ -823,6 +841,7 @@ class TestXMLFileBacked(TestFileBacked): fam.AddMonitor.assert_called_with("/test/test4.xml", xfb) self.assertIn("/test/test4.xml", xfb.extras) + class TestStructFile(TestXMLFileBacked): def _get_test_data(self): """ build a very complex set of test data """ @@ -893,22 +912,6 @@ class TestStructFile(TestXMLFileBacked): children[4] = standalone return (xdata, groups, subgroups, children, subchildren, standalone) - def assertXMLEqual(self, el1, el2, msg=None): - self.assertEqual(el1.tag, el2.tag, msg=msg) - self.assertEqual(el1.text, el2.text, msg=msg) - self.assertItemsEqual(el1.attrib, el2.attrib, msg=msg) - self.assertEqual(len(el1.getchildren()), - len(el2.getchildren())) - for child1 in el1.getchildren(): - cname = child1.get("name") - self.assertIsNotNone(cname, - msg="Element %s has no 'name' attribute" % - child1.tag) - children2 = el2.xpath("*[@name='%s']" % cname) - self.assertEqual(len(children2), 1, - msg="More than one element named %s" % cname) - self.assertXMLEqual(child1, children2[0], msg=msg) - def test_include_element(self): sf = StructFile("/test/test.xml") metadata = Mock() @@ -1045,6 +1048,272 @@ class TestStructFile(TestXMLFileBacked): self.assertXMLEqual(xactual, xexpected) +# INode.__init__ and INode._load_children() call each other +# recursively, which makes this class kind of a nightmare to test. we +# have to first patch INode._load_children so that we can create an +# INode object with no children loaded, then we unpatch +# INode._load_children and patch INode.__init__ so that child objects +# aren't actually created. but in order to test things atomically, we +# do this umpteen times in order to test with different data. we +# write our own context manager to make this a little easier. fun fun +# fun. +class patch_inode(object): + def __init__(self, test_obj, data, idict): + self.test_obj = test_obj + self.data = data + self.idict = idict + self.patch_init = None + self.inode = None + + def __enter__(self): + with patch("Bcfg2.Server.Plugin.%s._load_children" % + self.test_obj.__name__): + self.inode = self.test_obj(self.data, self.idict) + self.patch_init = patch("Bcfg2.Server.Plugin.%s.__init__" % + self.inode.__class__.__name__, + new=Mock(return_value=None)) + self.patch_init.start() + self.inode._load_children(self.data, self.idict) + return (self.inode, self.patch_init.new) + + def __exit__(self, type, value, traceback): + self.patch_init.stop() + del self.patch_init + del self.inode + + +class TestINode(Bcfg2TestCase): + test_obj = INode + + def test_raw_predicates(self): + metadata = Mock() + metadata.groups = ["group1", "group2"] + metadata.hostname = "foo.example.com" + entry = None + + parent_predicate = lambda m, e: True + pred = eval(self.test_obj.raw['Client'] % dict(name="foo.example.com"), + dict(predicate=parent_predicate)) + self.assertTrue(pred(metadata, entry)) + pred = eval(self.test_obj.raw['Client'] % dict(name="bar.example.com"), + dict(predicate=parent_predicate)) + self.assertFalse(pred(metadata, entry)) + + pred = eval(self.test_obj.raw['Group'] % dict(name="group1"), + dict(predicate=parent_predicate)) + self.assertTrue(pred(metadata, entry)) + pred = eval(self.test_obj.raw['Group'] % dict(name="group3"), + dict(predicate=parent_predicate)) + self.assertFalse(pred(metadata, entry)) + + pred = eval(self.test_obj.nraw['Client'] % dict(name="foo.example.com"), + dict(predicate=parent_predicate)) + self.assertFalse(pred(metadata, entry)) + pred = eval(self.test_obj.nraw['Client'] % dict(name="bar.example.com"), + dict(predicate=parent_predicate)) + self.assertTrue(pred(metadata, entry)) + + pred = eval(self.test_obj.nraw['Group'] % dict(name="group1"), + dict(predicate=parent_predicate)) + self.assertFalse(pred(metadata, entry)) + pred = eval(self.test_obj.nraw['Group'] % dict(name="group3"), + dict(predicate=parent_predicate)) + self.assertTrue(pred(metadata, entry)) + + parent_predicate = lambda m, e: False + pred = eval(self.test_obj.raw['Client'] % dict(name="foo.example.com"), + dict(predicate=parent_predicate)) + self.assertFalse(pred(metadata, entry)) + pred = eval(self.test_obj.raw['Group'] % dict(name="group1"), + dict(predicate=parent_predicate)) + self.assertFalse(pred(metadata, entry)) + pred = eval(self.test_obj.nraw['Client'] % dict(name="bar.example.com"), + dict(predicate=parent_predicate)) + self.assertFalse(pred(metadata, entry)) + pred = eval(self.test_obj.nraw['Group'] % dict(name="group3"), + dict(predicate=parent_predicate)) + self.assertFalse(pred(metadata, entry)) + + self.assertItemsEqual(self.test_obj.containers, + self.test_obj.raw.keys()) + self.assertItemsEqual(self.test_obj.containers, + self.test_obj.nraw.keys()) + + @patch("Bcfg2.Server.Plugin.INode._load_children") + def test__init(self, mock_load_children): + data = lxml.etree.Element("Bogus") + # called with no parent, should not raise an exception; it's a + # top-level tag in an XML file and so is not expected to be a + # proper predicate + INode(data, dict()) + self.assertRaises(PluginExecutionError, + INode, data, dict(), Mock()) + + data = lxml.etree.Element("Client", name="foo.example.com") + idict = dict() + inode = INode(data, idict) + mock_load_children.assert_called_with(data, idict) + self.assertTrue(inode.predicate(Mock(), Mock())) + + parent = Mock() + parent.predicate = lambda m, e: True + metadata = Mock() + metadata.groups = ["group1", "group2"] + metadata.hostname = "foo.example.com" + entry = None + + # test setting predicate with parent object + mock_load_children.reset_mock() + inode = INode(data, idict, parent=parent) + mock_load_children.assert_called_with(data, idict) + self.assertTrue(inode.predicate(metadata, entry)) + + # test negation + data = lxml.etree.Element("Client", name="foo.example.com", + negate="true") + mock_load_children.reset_mock() + inode = INode(data, idict, parent=parent) + mock_load_children.assert_called_with(data, idict) + self.assertFalse(inode.predicate(metadata, entry)) + + # test failure of a matching predicate (client names do not match) + data = lxml.etree.Element("Client", name="foo.example.com") + metadata.hostname = "bar.example.com" + mock_load_children.reset_mock() + inode = INode(data, idict, parent=parent) + mock_load_children.assert_called_with(data, idict) + self.assertFalse(inode.predicate(metadata, entry)) + + # test that parent predicate is AND'ed in correctly + parent.predicate = lambda m, e: False + metadata.hostname = "foo.example.com" + mock_load_children.reset_mock() + inode = INode(data, idict, parent=parent) + mock_load_children.assert_called_with(data, idict) + self.assertFalse(inode.predicate(metadata, entry)) + + def test_load_children(self): + data = lxml.etree.Element("Parent") + child1 = lxml.etree.SubElement(data, "Client", name="foo.example.com") + child2 = lxml.etree.SubElement(data, "Group", name="bar", negate="true") + idict = dict() + with patch_inode(self.test_obj, data, idict) as (inode, mock_init): + self.assertItemsEqual(mock_init.call_args_list, + [call(child1, idict, inode), + call(child2, idict, inode)]) + self.assertEqual(idict, dict()) + self.assertItemsEqual(inode.contents, dict()) + + data = lxml.etree.Element("Parent") + child1 = lxml.etree.SubElement(data, "Data", name="child1", + attr="some attr") + child1.text = "text" + subchild1 = lxml.etree.SubElement(child1, "SubChild", name="subchild") + child2 = lxml.etree.SubElement(data, "Group", name="bar", negate="true") + idict = dict() + with patch_inode(self.test_obj, data, idict) as (inode, mock_init): + mock_init.assert_called_with(child2, idict, inode) + tag = child1.tag + name = child1.get("name") + self.assertEqual(idict, dict(Data=[name])) + self.assertIn(tag, inode.contents) + self.assertIn(name, inode.contents[tag]) + self.assertItemsEqual(inode.contents[tag][name], + dict(name=name, + attr=child1.get('attr'), + __text__=child1.text, + __children__=[subchild1])) + + # test ignore. no ignore is set on INode by default, so we + # have to set one + old_ignore = copy.copy(self.test_obj.ignore) + self.test_obj.ignore.append("Data") + idict = dict() + with patch_inode(self.test_obj, data, idict) as (inode, mock_init): + mock_init.assert_called_with(child2, idict, inode) + self.assertEqual(idict, dict()) + self.assertItemsEqual(inode.contents, dict()) + self.test_obj.ignore = old_ignore + + def test_Match(self): + idata = lxml.etree.Element("Parent") + contents = lxml.etree.SubElement(idata, "Data", name="contents", + attr="some attr") + child = lxml.etree.SubElement(idata, "Group", name="bar", negate="true") + + inode = INode(idata, dict()) + inode.predicate = Mock() + inode.predicate.return_value = False + + metadata = Mock() + metadata.groups = ['foo'] + data = dict() + entry = child + + inode.Match(metadata, data, entry=child) + self.assertEqual(data, dict()) + inode.predicate.assert_called_with(metadata, child) + + inode.predicate.reset_mock() + inode.Match(metadata, data) + self.assertEqual(data, dict()) + # can't easily compare XML args without the original + # object, and we're testing that Match() works without an + # XML object passed in, so... + self.assertEqual(inode.predicate.call_args[0][0], + metadata) + self.assertXMLEqual(inode.predicate.call_args[0][1], + lxml.etree.Element("None")) + + inode.predicate.reset_mock() + inode.predicate.return_value = True + inode.Match(metadata, data, entry=child) + self.assertEqual(data, inode.contents) + inode.predicate.assert_called_with(metadata, child) + + +class TestInfoNode(TestINode): + __test__ = True + test_obj = InfoNode + + def test_raw_predicates(self): + TestINode.test_raw_predicates(self) + metadata = Mock() + entry = lxml.etree.Element("Path", name="/tmp/foo", + realname="/tmp/bar") + + parent_predicate = lambda m, d: True + pred = eval(self.test_obj.raw['Path'] % dict(name="/tmp/foo"), + dict(predicate=parent_predicate)) + self.assertTrue(pred(metadata, entry)) + pred = eval(InfoNode.raw['Path'] % dict(name="/tmp/bar"), + dict(predicate=parent_predicate)) + self.assertTrue(pred(metadata, entry)) + pred = eval(InfoNode.raw['Path'] % dict(name="/tmp/bogus"), + dict(predicate=parent_predicate)) + self.assertFalse(pred(metadata, entry)) + + pred = eval(self.test_obj.nraw['Path'] % dict(name="/tmp/foo"), + dict(predicate=parent_predicate)) + self.assertFalse(pred(metadata, entry)) + pred = eval(InfoNode.nraw['Path'] % dict(name="/tmp/bar"), + dict(predicate=parent_predicate)) + self.assertFalse(pred(metadata, entry)) + pred = eval(InfoNode.nraw['Path'] % dict(name="/tmp/bogus"), + dict(predicate=parent_predicate)) + self.assertTrue(pred(metadata, entry)) + + parent_predicate = lambda m, d: False + pred = eval(self.test_obj.raw['Path'] % dict(name="/tmp/foo"), + dict(predicate=parent_predicate)) + self.assertFalse(pred(metadata, entry)) + pred = eval(InfoNode.raw['Path'] % dict(name="/tmp/bar"), + dict(predicate=parent_predicate)) + self.assertFalse(pred(metadata, entry)) + pred = eval(InfoNode.nraw['Path'] % dict(name="/tmp/bogus"), + dict(predicate=parent_predicate)) + self.assertFalse(pred(metadata, entry)) + -class TestEntrySet(unittest.TestCase): +class TestEntrySet(Bcfg2TestCase): pass -- cgit v1.2.3-1-g7c22 From 836e995a7ab50c838ebff190f371b493d905a31c Mon Sep 17 00:00:00 2001 From: "Chris St. Pierre" Date: Mon, 13 Aug 2012 15:02:46 -0400 Subject: abstracted out some common test stuff into common.py --- testsuite/Testlib/TestOptions.py | 8 +- testsuite/Testlib/TestServer/TestPlugin.py | 27 +--- .../Testlib/TestServer/TestPlugins/TestMetadata.py | 161 ++++++++++----------- .../Testlib/TestServer/TestPlugins/TestProbes.py | 83 ++++------- testsuite/__init__.py | 0 testsuite/common.py | 77 ++++++++++ 6 files changed, 184 insertions(+), 172 deletions(-) create mode 100644 testsuite/__init__.py create mode 100644 testsuite/common.py (limited to 'testsuite') diff --git a/testsuite/Testlib/TestOptions.py b/testsuite/Testlib/TestOptions.py index 2129b9287..4c87b2f42 100644 --- a/testsuite/Testlib/TestOptions.py +++ b/testsuite/Testlib/TestOptions.py @@ -3,9 +3,9 @@ import sys import unittest from mock import Mock, patch import Bcfg2.Options +from ..common import * - -class TestOption(unittest.TestCase): +class TestOption(Bcfg2TestCase): def test__init(self): self.assertRaises(Bcfg2.Options.OptionFailure, Bcfg2.Options.Option, @@ -68,7 +68,7 @@ class TestOption(unittest.TestCase): assert o2.value == True -class TestOptionSet(unittest.TestCase): +class TestOptionSet(Bcfg2TestCase): def test_buildGetopt(self): opts = [('foo', Bcfg2.Options.Option('foo', 'test1', cmd='-G')), ('bar', Bcfg2.Options.Option('foo', 'test2')), @@ -108,7 +108,7 @@ class TestOptionSet(unittest.TestCase): self.assertTrue(oset3['foo']) -class TestOptionParser(unittest.TestCase): +class TestOptionParser(Bcfg2TestCase): def test__init(self): opts = [('foo', Bcfg2.Options.Option('foo', 'test1', cmd='-h')), ('bar', Bcfg2.Options.Option('foo', 'test2')), diff --git a/testsuite/Testlib/TestServer/TestPlugin.py b/testsuite/Testlib/TestServer/TestPlugin.py index 0ce32eb91..973994b2e 100644 --- a/testsuite/Testlib/TestServer/TestPlugin.py +++ b/testsuite/Testlib/TestServer/TestPlugin.py @@ -6,32 +6,7 @@ import lxml.etree from mock import Mock, MagicMock, patch from Bcfg2.Server.Plugin import * import Bcfg2.Server - -datastore = '/' - -def call(*args, **kwargs): - """ the Mock call object is a fairly recent addition, but it's - very very useful, so we create our own function to create Mock - calls """ - return (args, kwargs) - -class Bcfg2TestCase(unittest.TestCase): - def assertXMLEqual(self, el1, el2, msg=None): - self.assertEqual(el1.tag, el2.tag, msg=msg) - self.assertEqual(el1.text, el2.text, msg=msg) - self.assertItemsEqual(el1.attrib, el2.attrib, msg=msg) - self.assertEqual(len(el1.getchildren()), - len(el2.getchildren())) - for child1 in el1.getchildren(): - cname = child1.get("name") - self.assertIsNotNone(cname, - msg="Element %s has no 'name' attribute" % - child1.tag) - children2 = el2.xpath("*[@name='%s']" % cname) - self.assertEqual(len(children2), 1, - msg="More than one element named %s" % cname) - self.assertXMLEqual(child1, children2[0], msg=msg) - +from ...common import * class FakeElementTree(lxml.etree._ElementTree): xinclude = Mock() diff --git a/testsuite/Testlib/TestServer/TestPlugins/TestMetadata.py b/testsuite/Testlib/TestServer/TestPlugins/TestMetadata.py index 6926d6eef..3eb242d89 100644 --- a/testsuite/Testlib/TestServer/TestPlugins/TestMetadata.py +++ b/testsuite/Testlib/TestServer/TestPlugins/TestMetadata.py @@ -6,29 +6,13 @@ import socket import unittest import lxml.etree from mock import Mock, patch - -try: - from django.core.management import setup_environ - has_django = True - - os.environ['DJANGO_SETTINGS_MODULE'] = "Bcfg2.settings" - - import Bcfg2.settings - Bcfg2.settings.DATABASE_NAME = \ - os.path.join(os.path.dirname(os.path.abspath(__file__)), "test.sqlite") - Bcfg2.settings.DATABASES['default']['NAME'] = Bcfg2.settings.DATABASE_NAME -except ImportError: - has_django = False - +from ....common import * import Bcfg2.Server import Bcfg2.Server.Plugin from Bcfg2.Server.Plugins.Metadata import * from ..TestPlugin import TestXMLFileBacked, TestMetadata, TestStatistics, \ TestDatabaseBacked -XI_NAMESPACE = "http://www.w3.org/2001/XInclude" -XI = "{%s}" % XI_NAMESPACE - clients_test_tree = lxml.etree.XML(''' ''').getroottree() -datastore = "/" - -def test_syncdb(): - if not has_django: - raise unittest.SkipTest("Django not found, skipping") - - # create the test database - setup_environ(Bcfg2.settings) - from django.core.management.commands import syncdb - cmd = syncdb.Command() - cmd.handle_noargs(interactive=False) - assert os.path.exists(Bcfg2.settings.DATABASE_NAME) - - # ensure that we a) can connect to the database; b) start with a - # clean database - MetadataClientModel.objects.all().delete() - assert list(MetadataClientModel.objects.all()) == [] def get_metadata_object(core=None, watch_clients=False, use_db=False): if core is None: @@ -115,7 +82,11 @@ def get_metadata_object(core=None, watch_clients=False, use_db=False): return Metadata(core, datastore, watch_clients=watch_clients) -class TestClientVersions(unittest.TestCase): +class TestMetadataDB(DBModelTestCase): + models = [MetadataClientModel] + + +class TestClientVersions(Bcfg2TestCase): test_clients = dict(client1="1.2.0", client2="1.2.2", client3="1.3.0pre1", @@ -124,7 +95,7 @@ class TestClientVersions(unittest.TestCase): client6=None) def setUp(self): - test_syncdb() + syncdb(TestMetadataDB) for client, version in self.test_clients.items(): MetadataClientModel(hostname=client, version=version).save() @@ -361,7 +332,7 @@ class TestXMLMetadataConfig(TestXMLFileBacked): mock_load_xml.assert_called_with() -class TestClientMetadata(unittest.TestCase): +class TestClientMetadata(Bcfg2TestCase): def test_inGroup(self): cm = ClientMetadata("client1", "group1", ["group1", "group2"], ["bundle1"], [], [], [], None, None, None, None) @@ -631,7 +602,8 @@ class TestMetadata(TestMetadata, TestStatistics, TestDatabaseBacked): def load_clients_data(self, metadata=None, xdata=None): if metadata is None: metadata = self.get_metadata_object() - metadata.clients_xml.data = xdata or copy.deepcopy(self.clients_test_tree) + metadata.clients_xml.data = \ + xdata or copy.deepcopy(self.clients_test_tree) metadata.clients_xml.basedata = copy.copy(metadata.clients_xml.data) evt = Mock() evt.filename = os.path.join(datastore, "Metadata", "clients.xml") @@ -850,48 +822,61 @@ class TestMetadata(TestMetadata, TestStatistics, TestDatabaseBacked): # test address, password metadata.get_initial_metadata("client1") - self.assertEqual(mock_clientmetadata.call_args[0][:9], - ("client1", "group1", set(["group1"]), set(), set(), - set(["1.2.3.1"]), dict(category1='group1'), None, - 'password2')) + mock_clientmetadata.assert_called_with("client1", "group1", + set(["group1"]), set(), set(), + set(["1.2.3.1"]), + dict(category1='group1'), None, + 'password2', None, + metadata.query) # test address, bundles, category suppression metadata.get_initial_metadata("client2") - self.assertEqual(mock_clientmetadata.call_args[0][:9], - ("client2", "group2", set(["group2"]), - set(["bundle1", "bundle2"]), set(), - set(["1.2.3.2"]), dict(category1="group2"), - None, None)) + mock_clientmetadata.assert_called_with("client2", "group2", + set(["group2"]), + set(["bundle1", "bundle2"]), + set(), set(["1.2.3.2"]), + dict(category1="group2"), + None, None, None, + metadata.query) # test aliases, address, uuid, password imd = metadata.get_initial_metadata("alias1") - self.assertEqual(mock_clientmetadata.call_args[0][:9], - ("client3", "group1", set(["group1"]), set(), - set(['alias1']), set(["1.2.3.3"]), - dict(category1="group1"), 'uuid1', 'password2')) + mock_clientmetadata.assert_called_with("client3", "group1", + set(["group1"]), set(), + set(['alias1']), + set(["1.2.3.3"]), + dict(category1="group1"), + 'uuid1', 'password2', None, + metadata.query) # test new client creation new1 = self.get_nonexistent_client(metadata) imd = metadata.get_initial_metadata(new1) - self.assertEqual(mock_clientmetadata.call_args[0][:9], - (new1, "group1", set(["group1"]), set(), - set(), set(), dict(category1="group1"), None, None)) + mock_clientmetadata.assert_called_with(new1, "group1", set(["group1"]), + set(), set(), set(), + dict(category1="group1"), None, + None, None, metadata.query) # test nested groups, address, per-client groups imd = metadata.get_initial_metadata("client8") - self.assertEqual(mock_clientmetadata.call_args[0][:9], - ("client8", "group1", - set(["group1", "group8", "group9", "group10"]), set(), - set(), set(["1.2.3.5"]), dict(category1="group1"), - None, None)) + mock_clientmetadata.assert_called_with("client8", "group1", + set(["group1", "group8", + "group9", "group10"]), + set(), + set(), set(["1.2.3.5"]), + dict(category1="group1"), + None, None, None, metadata.query) # test setting per-client groups, group negation, nested groups imd = metadata.get_initial_metadata("client9") - self.assertEqual(mock_clientmetadata.call_args[0][:9], - ("client9", "group2", - set(["group2", "group8", "group11"]), - set(["bundle1", "bundle2"]), set(), set(), - dict(category1="group2"), None, "password3")) + mock_clientmetadata.assert_called_with("client9", "group2", + set(["group2", "group8", + "group11"]), + set(["bundle1", "bundle2"]), + set(), set(), + dict(category1="group2"), None, + "password3", None, + metadata.query) # test new client with no default profile metadata.default = None @@ -1120,7 +1105,7 @@ class TestMetadataBase(TestMetadata): def __init__(self, *args, **kwargs): TestMetadata.__init__(self, *args, **kwargs) - test_syncdb() + syncdb(TestMetadataDB) def setUp(self): if not has_django: @@ -1251,38 +1236,46 @@ class TestMetadata_NoClientsXML(TestMetadataBase): # test basic client metadata metadata.get_initial_metadata("client1") - self.assertEqual(mock_clientmetadata.call_args[0][:9], - ("client1", "group1", set(["group1"]), set(), set(), - set(), dict(category1='group1'), None, None)) + mock_clientmetadata.assert_called_with("client1", "group1", + set(["group1"]), set(), set(), + set(), dict(category1='group1'), + None, None, None, metadata.query) # test bundles, category suppression metadata.get_initial_metadata("client2") - self.assertEqual(mock_clientmetadata.call_args[0][:9], - ("client2", "group2", set(["group2"]), - set(["bundle1", "bundle2"]), set(), set(), - dict(category1="group2"), None, None)) + mock_clientmetadata.assert_called_with("client2", "group2", + set(["group2"]), + set(["bundle1", "bundle2"]), + set(), set(), + dict(category1="group2"), None, + None, None, metadata.query) # test new client creation new1 = self.get_nonexistent_client(metadata) imd = metadata.get_initial_metadata(new1) - self.assertEqual(mock_clientmetadata.call_args[0][:9], - (new1, "group1", set(["group1"]), set(), set(), set(), - dict(category1="group1"), None, None)) + mock_clientmetadata.assert_called_with(new1, "group1", set(["group1"]), + set(), set(), set(), + dict(category1="group1"), None, + None, None, metadata.query) # test nested groups, per-client groups imd = metadata.get_initial_metadata("client8") - self.assertEqual(mock_clientmetadata.call_args[0][:9], - ("client8", "group1", - set(["group1", "group8", "group9", "group10"]), set(), - set(), set(), dict(category1="group1"), None, None)) + mock_clientmetadata.assert_called_with("client8", "group1", + set(["group1", "group8", + "group9", "group10"]), + set(), set(), set(), + dict(category1="group1"), None, + None, None, metadata.query) # test per-client groups, group negation, nested groups imd = metadata.get_initial_metadata("client9") - self.assertEqual(mock_clientmetadata.call_args[0][:9], - ("client9", "group2", - set(["group2", "group8", "group11"]), - set(["bundle1", "bundle2"]), set(), set(), - dict(category1="group2"), None, None)) + mock_clientmetadata.assert_called_with("client9", "group2", + set(["group2", "group8", + "group11"]), + set(["bundle1", "bundle2"]), + set(), set(), + dict(category1="group2"), None, + None, None, metadata.query) # test exception on new client with no default profile metadata.default = None diff --git a/testsuite/Testlib/TestServer/TestPlugins/TestProbes.py b/testsuite/Testlib/TestServer/TestPlugins/TestProbes.py index fc901af68..816f9c370 100644 --- a/testsuite/Testlib/TestServer/TestPlugins/TestProbes.py +++ b/testsuite/Testlib/TestServer/TestPlugins/TestProbes.py @@ -4,54 +4,25 @@ import time import unittest import lxml.etree from mock import Mock, patch - -try: - from django.core.management import setup_environ - has_django = True - - os.environ['DJANGO_SETTINGS_MODULE'] = "Bcfg2.settings" - - import Bcfg2.settings - Bcfg2.settings.DATABASE_NAME = \ - os.path.join(os.path.dirname(os.path.abspath(__file__)), "test.sqlite") - Bcfg2.settings.DATABASES['default']['NAME'] = Bcfg2.settings.DATABASE_NAME -except ImportError: - has_django = False - +from ....common import * import Bcfg2.Server import Bcfg2.Server.Plugin from Bcfg2.Server.Plugins.Probes import * from ..TestPlugin import TestEntrySet, TestProbing, TestConnector, \ TestDatabaseBacked -datastore = "/" - # test data for JSON and YAML tests test_data = dict(a=1, b=[1, 2, 3], c="test") -def test_syncdb(): - if not has_django: - raise unittest.SkipTest("Django not found, skipping") - - # create the test database - setup_environ(Bcfg2.settings) - from django.core.management.commands import syncdb - cmd = syncdb.Command() - cmd.handle_noargs(interactive=False) - assert os.path.exists(Bcfg2.settings.DATABASE_NAME) - - # ensure that we a) can connect to the database; b) start with a - # clean database - ProbesDataModel.objects.all().delete() - ProbesGroupsModel.objects.all().delete() - assert list(ProbesDataModel.objects.all()) == [] - - class FakeList(list): sort = Mock() -class TestClientProbeDataSet(unittest.TestCase): +class TestProbesDB(DBModelTestCase): + models = [ProbesGroupsModel, ProbesDataModel] + + +class TestClientProbeDataSet(Bcfg2TestCase): def test__init(self): ds = ClientProbeDataSet() self.assertLessEqual(ds.timestamp, time.time()) @@ -62,7 +33,7 @@ class TestClientProbeDataSet(unittest.TestCase): self.assertEqual(ds.timestamp, 123) self.assertNotIn("timestamp", ds) -class TestProbeData(unittest.TestCase): +class TestProbeData(Bcfg2TestCase): def test_str(self): # a value that is not valid XML, JSON, or YAML val = "'test" @@ -251,19 +222,20 @@ text "use_database", default=False) + @unittest.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(self): + def test_write_data_xml(self): probes = self.get_probes_object(use_db=False) probes.write_data("test") probes._write_data_xml.assert_called_with("test") self.assertFalse(probes._write_data_db.called) - if not has_django: - self.skipTest("Django not found, skipping") + @unittest.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) - probes._write_data_xml.reset_mock() - probes._write_data_db.reset_mock() probes.write_data("test") probes._write_data_db.assert_called_with("test") self.assertFalse(probes._write_data_xml.called) @@ -324,10 +296,9 @@ text self.assertIsNotNone(jdata.get("value")) self.assertItemsEqual(test_data, json.loads(jdata.get("value"))) + @unittest.skipUnless(has_django, "Django not found, skipping") def test__write_data_db(self): - if not has_django: - self.skipTest("Django not found, skipping") - test_syncdb() + syncdb(TestProbesDB) probes = self.get_probes_object(use_db=True) probes.probedata = self.get_test_probedata() probes.cgroups = self.get_test_cgroups() @@ -377,23 +348,20 @@ text pgroups = ProbesGroupsModel.objects.filter(hostname=cname).all() self.assertEqual(len(pgroups), len(probes.cgroups[cname])) + @unittest.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(self): + def test_load_data_xml(self): probes = self.get_probes_object(use_db=False) - probes._load_data_xml.reset_mock() - probes._load_data_db.reset_mock() - probes.load_data() probes._load_data_xml.assert_any_call() self.assertFalse(probes._load_data_db.called) - if not has_django: - self.skipTest("Django not found, skipping") - + @unittest.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) - probes._load_data_xml.reset_mock() - probes._load_data_db.reset_mock() probes.load_data() probes._load_data_db.assert_any_call() self.assertFalse(probes._load_data_xml.called) @@ -421,10 +389,9 @@ text self.assertItemsEqual(probes.probedata, self.get_test_probedata()) self.assertItemsEqual(probes.cgroups, self.get_test_cgroups()) + @unittest.skipUnless(has_django, "Django not found, skipping") def test__load_data_db(self): - if not has_django: - self.skipTest("Django not found, skipping") - test_syncdb() + syncdb(TestProbesDB) probes = self.get_probes_object(use_db=True) probes.probedata = self.get_test_probedata() probes.cgroups = self.get_test_cgroups() @@ -468,8 +435,8 @@ text probes.ReceiveData(client, datalist) self.assertItemsEqual(mock_ReceiveDataItem.call_args_list, - [((client, "a"), {}), ((client, "b"), {}), - ((client, "c"), {})]) + [call(client, "a"), call(client, "b"), + call(client, "c")]) mock_write_data.assert_called_with(client) def test_ReceiveDataItem(self): diff --git a/testsuite/__init__.py b/testsuite/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/testsuite/common.py b/testsuite/common.py new file mode 100644 index 000000000..006b45970 --- /dev/null +++ b/testsuite/common.py @@ -0,0 +1,77 @@ +import os +import unittest + +__all__ = ['call', 'datastore', 'Bcfg2TestCase', 'DBModelTestCase', 'syncdb', + 'XI', 'XI_NAMESPACE'] + +datastore = "/" + +XI_NAMESPACE = "http://www.w3.org/2001/XInclude" +XI = "{%s}" % XI_NAMESPACE + +try: + from django.core.management import setup_environ + has_django = True + + os.environ['DJANGO_SETTINGS_MODULE'] = "Bcfg2.settings" + + import Bcfg2.settings + Bcfg2.settings.DATABASE_NAME = \ + os.path.join(os.path.dirname(os.path.abspath(__file__)), "test.sqlite") + Bcfg2.settings.DATABASES['default']['NAME'] = Bcfg2.settings.DATABASE_NAME +except ImportError: + has_django = False + +try: + from mock import call +except ImportError: + def call(*args, **kwargs): + """ the Mock call object is a fairly recent addition, but it's + very very useful, so we create our own function to create Mock + calls """ + return (args, kwargs) + + +class Bcfg2TestCase(unittest.TestCase): + def assertXMLEqual(self, el1, el2, msg=None): + self.assertEqual(el1.tag, el2.tag, msg=msg) + self.assertEqual(el1.text, el2.text, msg=msg) + self.assertItemsEqual(el1.attrib, el2.attrib, msg=msg) + self.assertEqual(len(el1.getchildren()), + len(el2.getchildren())) + for child1 in el1.getchildren(): + cname = child1.get("name") + self.assertIsNotNone(cname, + msg="Element %s has no 'name' attribute" % + child1.tag) + children2 = el2.xpath("*[@name='%s']" % cname) + self.assertEqual(len(children2), 1, + msg="More than one element named %s" % cname) + self.assertXMLEqual(child1, children2[0], msg=msg) + + +class DBModelTestCase(Bcfg2TestCase): + models = [] + + @unittest.skipUnless(has_django, "Django not found, skipping") + def test_syncdb(self): + # create the test database + setup_environ(Bcfg2.settings) + from django.core.management.commands import syncdb + cmd = syncdb.Command() + cmd.handle_noargs(interactive=False) + self.assertTrue(os.path.exists(Bcfg2.settings.DATABASE_NAME)) + + @unittest.skipUnless(has_django, "Django not found, skipping") + def test_cleandb(self): + """ ensure that we a) can connect to the database; b) start with a + clean database """ + for model in self.models: + model.objects.all().delete() + self.assertItemsEqual(list(model.objects.all()), []) + + +def syncdb(modeltest): + inst = modeltest(methodName='test_syncdb') + inst.test_syncdb() + inst.test_cleandb() -- cgit v1.2.3-1-g7c22 From 9f27d18c1bc14a570f40a77b0c97373e6ab58431 Mon Sep 17 00:00:00 2001 From: "Chris St. Pierre" Date: Mon, 13 Aug 2012 15:54:04 -0400 Subject: added tests for XMLSrc, InfoXML, XMLDirectoryBacked --- testsuite/Testlib/TestServer/TestPlugin.py | 110 +++++++++++++++++++++++++++-- 1 file changed, 103 insertions(+), 7 deletions(-) (limited to 'testsuite') diff --git a/testsuite/Testlib/TestServer/TestPlugin.py b/testsuite/Testlib/TestServer/TestPlugin.py index 973994b2e..1d9c004d5 100644 --- a/testsuite/Testlib/TestServer/TestPlugin.py +++ b/testsuite/Testlib/TestServer/TestPlugin.py @@ -443,6 +443,7 @@ class TestFileBacked(Bcfg2TestCase): class TestDirectoryBacked(Bcfg2TestCase): + test_obj = DirectoryBacked testpaths = {1: '', 2: '/foo', 3: '/foo/bar', @@ -451,15 +452,20 @@ class TestDirectoryBacked(Bcfg2TestCase): 6: 'xyzzy/', 7: 'xyzzy/plugh/'} - @patch("Bcfg2.Server.Plugin.DirectoryBacked.add_directory_monitor", Mock()) + def test_child_interface(self): + # ensure that the child object has the correct interface + self.assertTrue(hasattr(self.test_obj.__child__, "HandleEvent")) + + @patch("Bcfg2.Server.Plugin.%s.add_directory_monitor" % test_obj.__name__, + Mock()) def get_obj(self, fam=None): if fam is None: fam = Mock() - return DirectoryBacked(datastore, fam) + return self.test_obj(datastore, fam) - @patch("Bcfg2.Server.Plugin.DirectoryBacked.add_directory_monitor") + @patch("Bcfg2.Server.Plugin.%s.add_directory_monitor" % test_obj.__name__) def test__init(self, mock_add_monitor): - db = DirectoryBacked(datastore, Mock()) + db = self.test_obj(datastore, Mock()) mock_add_monitor.assert_called_with('') def test__getitem(self): @@ -532,8 +538,8 @@ class TestDirectoryBacked(Bcfg2TestCase): db.entries[path].HandleEvent.assert_called_with(event) @patch("os.path.isdir") - @patch("Bcfg2.Server.Plugin.DirectoryBacked.add_entry") - @patch("Bcfg2.Server.Plugin.DirectoryBacked.add_directory_monitor") + @patch("Bcfg2.Server.Plugin.%s.add_entry" % test_obj.__name__) + @patch("Bcfg2.Server.Plugin.%s.add_directory_monitor" % test_obj.__name__) def test_HandleEvent(self, mock_add_monitor, mock_add_entry, mock_isdir): fam = Mock() db = self.get_obj(fam=fam) @@ -1288,7 +1294,97 @@ class TestInfoNode(TestINode): pred = eval(InfoNode.nraw['Path'] % dict(name="/tmp/bogus"), dict(predicate=parent_predicate)) self.assertFalse(pred(metadata, entry)) + + +class TestXMLSrc(TestXMLFileBacked): + test_obj = XMLSrc + + def test_node_interface(self): + # ensure that the node object has the necessary interface + self.assertTrue(hasattr(self.test_obj.__node__, "Match")) + + @patch("__builtin__.open") + def test_HandleEvent(self, mock_open): + xdata = lxml.etree.Element("Test") + lxml.etree.SubElement(xdata, "Path", name="path", attr="whatever") + + xsrc = self.test_obj("/test/foo.xml") + xsrc.__node__ = Mock() + mock_open.return_value.read.return_value = lxml.etree.tostring(xdata) + + self.assertRaises(PluginExecutionError, + xsrc.HandleEvent, Mock()) + + xdata.set("priority", "cow") + mock_open.return_value.read.return_value = lxml.etree.tostring(xdata) + self.assertRaises(PluginExecutionError, + xsrc.HandleEvent, Mock()) + + xdata.set("priority", "10") + mock_open.return_value.read.return_value = lxml.etree.tostring(xdata) + + mock_open.reset_mock() + xsrc = self.test_obj("/test/foo.xml") + xsrc.__node__ = Mock() + xsrc.HandleEvent(Mock()) + mock_open.assert_called_with("/test/foo.xml") + mock_open.return_value.read.assert_any_call() + self.assertXMLEqual(xsrc.__node__.call_args[0][0], xdata) + self.assertEqual(xsrc.__node__.call_args[0][1], dict()) + self.assertEqual(xsrc.pnode, xsrc.__node__.return_value) + self.assertEqual(xsrc.cache, None) + + @patch("Bcfg2.Server.Plugin.XMLSrc.HandleEvent") + def test_Cache(self, mock_HandleEvent): + xsrc = self.test_obj("/test/foo.xml") + metadata = Mock() + xsrc.Cache(metadata) + mock_HandleEvent.assert_any_call() + xsrc.pnode = Mock() + xsrc.Cache(metadata) + xsrc.pnode.Match.assert_called_with(metadata, xsrc.__cacheobj__()) + self.assertEqual(xsrc.cache[0], metadata) + + xsrc.pnode.reset_mock() + xsrc.Cache(metadata) + self.assertFalse(xsrc.pnode.Mock.called) + self.assertEqual(xsrc.cache[0], metadata) + + xsrc.cache = ("bogus") + xsrc.Cache(metadata) + xsrc.pnode.Match.assert_called_with(metadata, xsrc.__cacheobj__()) + self.assertEqual(xsrc.cache[0], metadata) + + +class TestInfoXML(TestXMLSrc): + test_obj = InfoXML + + +class TestXMLDirectoryBacked(TestDirectoryBacked): + test_obj = XMLDirectoryBacked + + +class TestPrioDir(TestPlugin, TestGenerator, TestXMLDirectoryBacked): + pass + + +class SpecificityError(Bcfg2TestCase): + """ placeholder for future tests """ + pass + + +class Specificity(Bcfg2TestCase): + pass + + +class SpecificData(Bcfg2TestCase): + pass + + +class TestEntrySet(TestDebuggable): + pass + -class TestEntrySet(Bcfg2TestCase): +class GroupSpool(TestPlugin, TestGenerator): pass -- cgit v1.2.3-1-g7c22 From f8f62180e36ccc846315e309b62d17e732a3148f Mon Sep 17 00:00:00 2001 From: "Chris St. Pierre" Date: Tue, 14 Aug 2012 07:53:43 -0400 Subject: fixed test inheritance --- testsuite/Testlib/TestServer/TestPlugin.py | 178 ++++++++++++++------- .../Testlib/TestServer/TestPlugins/TestMetadata.py | 110 +++++++------ .../Testlib/TestServer/TestPlugins/TestProbes.py | 15 +- 3 files changed, 190 insertions(+), 113 deletions(-) (limited to 'testsuite') diff --git a/testsuite/Testlib/TestServer/TestPlugin.py b/testsuite/Testlib/TestServer/TestPlugin.py index 1d9c004d5..5c3c98502 100644 --- a/testsuite/Testlib/TestServer/TestPlugin.py +++ b/testsuite/Testlib/TestServer/TestPlugin.py @@ -66,14 +66,19 @@ class TestPluginExecutionError(Bcfg2TestCase): class TestDebuggable(Bcfg2TestCase): + test_obj = Debuggable + + def get_obj(self): + return self.test_obj() + def test__init(self): - d = Debuggable() + d = self.get_obj() self.assertIsInstance(d.logger, logging.Logger) self.assertFalse(d.debug_flag) - @patch("Bcfg2.Server.Plugin.Debuggable.debug_log") + @patch("Bcfg2.Server.Plugin.%s.debug_log" % test_obj.__name__) def test_toggle_debug(self, mock_debug): - d = Debuggable() + d = self.get_obj() orig = d.debug_flag d.toggle_debug() self.assertNotEqual(orig, d.debug_flag) @@ -88,7 +93,7 @@ class TestDebuggable(Bcfg2TestCase): self.assertTrue(mock_debug.called) def test_debug_log(self): - d = Debuggable() + d = self.get_obj() d.logger = Mock() d.debug_flag = False d.debug_log("test") @@ -105,40 +110,50 @@ class TestDebuggable(Bcfg2TestCase): class TestPlugin(TestDebuggable): + test_obj = Plugin + + def get_obj(self, core=None): + if core is None: + core = Mock() + return self.test_obj(core, datastore) + def test__init(self): core = Mock() - p = Plugin(core, datastore) + p = self.get_obj(core=core) self.assertEqual(p.data, os.path.join(datastore, p.name)) self.assertEqual(p.core, core) self.assertIsInstance(p, Debuggable) @patch("os.makedirs") def test_init_repo(self, mock_makedirs): - Plugin.init_repo(datastore) - mock_makedirs.assert_called_with(os.path.join(datastore, Plugin.name)) + self.test_obj.init_repo(datastore) + mock_makedirs.assert_called_with(os.path.join(datastore, + self.test_obj.name)) class TestDatabaseBacked(TestPlugin): + test_obj = DatabaseBacked + @unittest.skipUnless(has_django, "Django not found") def test__use_db(self): core = Mock() core.setup.cfp.getboolean.return_value = True - db = DatabaseBacked(core, datastore) + db = self.get_obj(core) self.assertTrue(db._use_db) core = Mock() core.setup.cfp.getboolean.return_value = False - db = DatabaseBacked(core, datastore) + db = self.get_obj(core) self.assertFalse(db._use_db) Bcfg2.Server.Plugin.has_django = False core = Mock() - db = DatabaseBacked(core, datastore) + db = self.get_obj(core) self.assertFalse(db._use_db) core = Mock() core.setup.cfp.getboolean.return_value = True - db = DatabaseBacked(core, datastore) + db = self.get_obj(core) self.assertFalse(db._use_db) Bcfg2.Server.Plugin.has_django = True @@ -190,25 +205,25 @@ class TestProbing(Bcfg2TestCase): class TestStatistics(TestPlugin): - """ placeholder """ - pass + test_obj = Statistics class TestThreadedStatistics(TestStatistics): + test_obj = ThreadedStatistics data = [("foo.example.com", ""), ("bar.example.com", "")] @patch("threading.Thread.start") def test__init(self, mock_start): core = Mock() - ts = ThreadedStatistics(core, datastore) + ts = self.get_obj(core) mock_start.assert_any_call() @patch("__builtin__.open") @patch("Bcfg2.Server.Plugin.ThreadedStatistics.run", Mock()) def test_save(self, mock_open): core = Mock() - ts = ThreadedStatistics(core, datastore) + ts = self.get_obj(core) queue = Mock() queue.empty = Mock(side_effect=Empty) ts.work_queue = queue @@ -253,7 +268,7 @@ class TestThreadedStatistics(TestStatistics): def test_load(self, mock_XML, mock_open, mock_exists, mock_unlink): core = Mock() core.terminate.isSet.return_value = False - ts = ThreadedStatistics(core, datastore) + ts = self.get_obj(core) with patch("%s.load" % cPickle.__name__) as mock_load: ts.work_queue = Mock() @@ -311,7 +326,7 @@ class TestThreadedStatistics(TestStatistics): @patch("Bcfg2.Server.Plugin.ThreadedStatistics.handle_statistic") def test_run(self, mock_handle, mock_save, mock_load): core = Mock() - ts = ThreadedStatistics(core, datastore) + ts = self.get_obj(core) mock_load.return_value = True ts.work_queue = Mock() @@ -350,7 +365,7 @@ class TestThreadedStatistics(TestStatistics): @patch("Bcfg2.Server.Plugin.ThreadedStatistics.run", Mock()) def test_process_statistics(self): core = Mock() - ts = ThreadedStatistics(core, datastore) + ts = self.get_obj(core) ts.work_queue = Mock() ts.process_statistics(*self.data[0]) ts.work_queue.put_nowait.assert_called_with(self.data[0]) @@ -415,14 +430,19 @@ class TestClientRunHooks(Bcfg2TestCase): class TestFileBacked(Bcfg2TestCase): + test_obj = FileBacked + + def get_obj(self, path=datastore, fam=None): + return self.test_obj(path, fam=fam) + @patch("__builtin__.open") - @patch("Bcfg2.Server.Plugin.FileBacked.Index") - def test_HandleEvent(self, mock_Index, mock_open): + def test_HandleEvent(self, mock_open): path = "/test" - fb = FileBacked(path) + fb = self.get_obj(path) + fb.Index = Mock() def reset(): - mock_Index.reset_mock() + fb.Index.reset_mock() mock_open.reset_mock() for evt in ["exists", "changed", "created"]: @@ -432,14 +452,14 @@ class TestFileBacked(Bcfg2TestCase): fb.HandleEvent(event) mock_open.assert_called_with(path) mock_open.return_value.read.assert_any_call() - mock_Index.assert_any_call() + fb.Index.assert_any_call() reset() event = Mock() event.code2str.return_value = "endExist" fb.HandleEvent(event) self.assertFalse(mock_open.called) - self.assertFalse(mock_Index.called) + self.assertFalse(fb.Index.called) class TestDirectoryBacked(Bcfg2TestCase): @@ -637,28 +657,33 @@ class TestDirectoryBacked(Bcfg2TestCase): class TestXMLFileBacked(TestFileBacked): + test_obj = XMLFileBacked + + def get_obj(self, path=datastore, fam=None, should_monitor=False): + return self.test_obj(path, fam=fam, should_monitor=should_monitor) + def test__init(self): fam = Mock() fname = "/test" - xfb = XMLFileBacked(fname) + xfb = self.get_obj(fname) self.assertIsNone(xfb.fam) - xfb = XMLFileBacked(fname, fam=fam) + xfb = self.get_obj(fname, fam=fam) self.assertFalse(fam.AddMonitor.called) fam.reset_mock() - xfb = XMLFileBacked(fname, fam=fam, should_monitor=True) + xfb = self.get_obj(fname, fam=fam, should_monitor=True) fam.AddMonitor.assert_called_with(fname, xfb) @patch("os.path.exists") @patch("lxml.etree.parse") - @patch("Bcfg2.Server.Plugin.XMLFileBacked.add_monitor") - def test_follow_xincludes(self, mock_add_monitor, mock_parse, mock_exists): + def test_follow_xincludes(self, mock_parse, mock_exists): fname = "/test/test1.xml" - xfb = XMLFileBacked(fname) + xfb = self.get_obj(fname) + xfb.add_monitor = Mock() def reset(): - mock_add_monitor.reset_mock() + xfb.add_monitor.reset_mock() mock_parse.reset_mock() mock_exists.reset_mock() xfb.extras = [] @@ -670,17 +695,21 @@ class TestXMLFileBacked(TestFileBacked): # basic functionality xdata['/test/test2.xml'] = lxml.etree.Element("Test").getroottree() xfb._follow_xincludes(xdata=xdata['/test/test2.xml']) - self.assertFalse(mock_add_monitor.called) + self.assertFalse(xfb.add_monitor.called) - reset() - xfb.xdata = xdata['/test/test2.xml'].getroot() - xfb._follow_xincludes() - self.assertFalse(mock_add_monitor.called) - xfb.xdata = None + if (not hasattr(self.test_obj, "xdata") or + not isinstance(self.test_obj.xdata, property)): + # if xdata is settable, test that method of getting data + # to _follow_xincludes + reset() + xfb.xdata = xdata['/test/test2.xml'].getroot() + xfb._follow_xincludes() + self.assertFalse(xfb.add_monitor.called) + xfb.xdata = None reset() xfb._follow_xincludes(fname="/test/test2.xml") - self.assertFalse(mock_add_monitor.called) + self.assertFalse(xfb.add_monitor.called) # test one level of xinclude xdata[fname] = lxml.etree.Element("Test").getroottree() @@ -689,14 +718,14 @@ class TestXMLFileBacked(TestFileBacked): href="/test/test2.xml") reset() xfb._follow_xincludes(fname=fname) - mock_add_monitor.assert_called_with("/test/test2.xml") + xfb.add_monitor.assert_called_with("/test/test2.xml") self.assertItemsEqual(mock_parse.call_args_list, [call(f) for f in xdata.keys()]) mock_exists.assert_called_with("/test/test2.xml") reset() xfb._follow_xincludes(xdata=xdata[fname]) - mock_add_monitor.assert_called_with("/test/test2.xml") + xfb.add_monitor.assert_called_with("/test/test2.xml") self.assertItemsEqual(mock_parse.call_args_list, [call(f) for f in xdata.keys() if f != fname]) @@ -728,7 +757,7 @@ class TestXMLFileBacked(TestFileBacked): reset() xfb._follow_xincludes(fname=fname) - self.assertItemsEqual(mock_add_monitor.call_args_list, + self.assertItemsEqual(xfb.add_monitor.call_args_list, [call(f) for f in xdata.keys() if f != fname]) self.assertItemsEqual(mock_parse.call_args_list, [call(f) for f in xdata.keys()]) @@ -737,7 +766,7 @@ class TestXMLFileBacked(TestFileBacked): reset() xfb._follow_xincludes(xdata=xdata[fname]) - self.assertItemsEqual(mock_add_monitor.call_args_list, + self.assertItemsEqual(xfb.add_monitor.call_args_list, [call(f) for f in xdata.keys() if f != fname]) self.assertItemsEqual(mock_parse.call_args_list, [call(f) for f in xdata.keys() if f != fname]) @@ -745,10 +774,10 @@ class TestXMLFileBacked(TestFileBacked): [call(f) for f in xdata.keys() if f != fname]) @patch("lxml.etree._ElementTree", FakeElementTree) - @patch("Bcfg2.Server.Plugin.XMLFileBacked._follow_xincludes") + @patch("Bcfg2.Server.Plugin.%s._follow_xincludes" % test_obj.__name__) def test_Index(self, mock_follow): fname = "/test/test1.xml" - xfb = XMLFileBacked(fname) + xfb = self.get_obj(fname) def reset(): mock_follow.reset_mock() @@ -805,25 +834,27 @@ class TestXMLFileBacked(TestFileBacked): def test_add_monitor(self): fname = "/test/test1.xml" - xfb = XMLFileBacked(fname) + xfb = self.get_obj(fname) xfb.add_monitor("/test/test2.xml") self.assertIn("/test/test2.xml", xfb.extras) fam = Mock() - xfb = XMLFileBacked(fname, fam=fam) + xfb = self.get_obj(fname, fam=fam) fam.reset_mock() xfb.add_monitor("/test/test3.xml") self.assertFalse(fam.AddMonitor.called) self.assertIn("/test/test3.xml", xfb.extras) fam.reset_mock() - xfb = XMLFileBacked(fname, fam=fam, should_monitor=True) + xfb = self.get_obj(fname, fam=fam, should_monitor=True) xfb.add_monitor("/test/test4.xml") fam.AddMonitor.assert_called_with("/test/test4.xml", xfb) self.assertIn("/test/test4.xml", xfb.extras) class TestStructFile(TestXMLFileBacked): + test_obj = StructFile + def _get_test_data(self): """ build a very complex set of test data """ # top-level group and client elements @@ -894,7 +925,7 @@ class TestStructFile(TestXMLFileBacked): return (xdata, groups, subgroups, children, subchildren, standalone) def test_include_element(self): - sf = StructFile("/test/test.xml") + sf = self.get_obj("/test/test.xml") metadata = Mock() metadata.groups = ["group1", "group2"] metadata.hostname = "foo.example.com" @@ -925,9 +956,9 @@ class TestStructFile(TestXMLFileBacked): self.assertTrue(inc("Other")) - @patch("Bcfg2.Server.Plugin.StructFile._include_element") + @patch("Bcfg2.Server.Plugin.%s._include_element" % test_obj.__name__) def test__match(self, mock_include): - sf = StructFile("/test/test.xml") + sf = self.get_obj("/test/test.xml") metadata = Mock() (xdata, groups, subgroups, children, subchildren, standalone) = \ @@ -953,9 +984,9 @@ class TestStructFile(TestXMLFileBacked): for el in standalone: self.assertXMLEqual(el, sf._match(el, metadata)[0]) - @patch("Bcfg2.Server.Plugin.StructFile._match") + @patch("Bcfg2.Server.Plugin.%s._match" % test_obj.__name__) def test_Match(self, mock_match): - sf = StructFile("/test/test.xml") + sf = self.get_obj("/test/test.xml") metadata = Mock() (xdata, groups, subgroups, children, subchildren, standalone) = \ @@ -983,9 +1014,9 @@ class TestStructFile(TestXMLFileBacked): xexpected.extend(expected) self.assertXMLEqual(xactual, xexpected) - @patch("Bcfg2.Server.Plugin.StructFile._include_element") + @patch("Bcfg2.Server.Plugin.%s._include_element" % test_obj.__name__) def test__xml_match(self, mock_include): - sf = StructFile("/test/test.xml") + sf = self.get_obj("/test/test.xml") metadata = Mock() (xdata, groups, subgroups, children, subchildren, standalone) = \ @@ -1005,9 +1036,9 @@ class TestStructFile(TestXMLFileBacked): expected.extend(standalone) self.assertXMLEqual(actual, expected) - @patch("Bcfg2.Server.Plugin.StructFile._xml_match") + @patch("Bcfg2.Server.Plugin.%s._xml_match" % test_obj.__name__) def test_Match(self, mock_xml_match): - sf = StructFile("/test/test.xml") + sf = self.get_obj("/test/test.xml") metadata = Mock() (sf.xdata, groups, subgroups, children, subchildren, standalone) = \ @@ -1308,7 +1339,7 @@ class TestXMLSrc(TestXMLFileBacked): xdata = lxml.etree.Element("Test") lxml.etree.SubElement(xdata, "Path", name="path", attr="whatever") - xsrc = self.test_obj("/test/foo.xml") + xsrc = self.get_obj("/test/foo.xml") xsrc.__node__ = Mock() mock_open.return_value.read.return_value = lxml.etree.tostring(xdata) @@ -1324,7 +1355,7 @@ class TestXMLSrc(TestXMLFileBacked): mock_open.return_value.read.return_value = lxml.etree.tostring(xdata) mock_open.reset_mock() - xsrc = self.test_obj("/test/foo.xml") + xsrc = self.get_obj("/test/foo.xml") xsrc.__node__ = Mock() xsrc.HandleEvent(Mock()) mock_open.assert_called_with("/test/foo.xml") @@ -1336,7 +1367,7 @@ class TestXMLSrc(TestXMLFileBacked): @patch("Bcfg2.Server.Plugin.XMLSrc.HandleEvent") def test_Cache(self, mock_HandleEvent): - xsrc = self.test_obj("/test/foo.xml") + xsrc = self.get_obj("/test/foo.xml") metadata = Mock() xsrc.Cache(metadata) mock_HandleEvent.assert_any_call() @@ -1366,8 +1397,28 @@ class TestXMLDirectoryBacked(TestDirectoryBacked): class TestPrioDir(TestPlugin, TestGenerator, TestXMLDirectoryBacked): - pass + test_obj = PrioDir + + def get_obj(self, core=None): + if core is None: + core = Mock() + return self.test_obj(core, datastore) + + def test_HandleEvent(self): + pass + + def test__iter(self): + pass + + def test__getitem(self): + pass + + def test_add_entry(self): + pass + def test_add_directory_monitor(self): + pass + class SpecificityError(Bcfg2TestCase): """ placeholder for future tests """ @@ -1383,8 +1434,13 @@ class SpecificData(Bcfg2TestCase): class TestEntrySet(TestDebuggable): - pass + test_obj = EntrySet + + def get_obj(self, basename="test", path=datastore, entry_type=SpecificData, + encoding=None): + return self.test_obj(basename, path, entry_type, encoding) class GroupSpool(TestPlugin, TestGenerator): + test_obj = GroupSpool pass diff --git a/testsuite/Testlib/TestServer/TestPlugins/TestMetadata.py b/testsuite/Testlib/TestServer/TestPlugins/TestMetadata.py index 3eb242d89..6aab04a89 100644 --- a/testsuite/Testlib/TestServer/TestPlugins/TestMetadata.py +++ b/testsuite/Testlib/TestServer/TestPlugins/TestMetadata.py @@ -10,8 +10,8 @@ from ....common import * import Bcfg2.Server import Bcfg2.Server.Plugin from Bcfg2.Server.Plugins.Metadata import * -from ..TestPlugin import TestXMLFileBacked, TestMetadata, TestStatistics, \ - TestDatabaseBacked +from ..TestPlugin import TestXMLFileBacked, TestMetadata as _TestMetadata, \ + TestStatistics, TestDatabaseBacked clients_test_tree = lxml.etree.XML(''' @@ -77,8 +77,7 @@ groups_test_tree = lxml.etree.XML(''' def get_metadata_object(core=None, watch_clients=False, use_db=False): if core is None: core = Mock() - core.setup.cfp.getboolean = Mock() - core.setup.cfp.getboolean.return_value = use_db + core.setup.cfp.getboolean = Mock(return_value=use_db) return Metadata(core, datastore, watch_clients=watch_clients) @@ -167,24 +166,29 @@ class TestClientVersions(Bcfg2TestCase): class TestXMLMetadataConfig(TestXMLFileBacked): + test_obj = XMLMetadataConfig groups_test_tree = groups_test_tree clients_test_tree = clients_test_tree - def get_config_object(self, basefile="clients.xml", core=None, - watch_clients=False): + def get_obj(self, basefile="clients.xml", core=None, watch_clients=False): self.metadata = get_metadata_object(core=core, watch_clients=watch_clients) return XMLMetadataConfig(self.metadata, watch_clients, basefile) + def test__init(self): + xmc = self.get_obj() + self.assertEqual(self.metadata.core.fam, xmc.fam) + self.assertFalse(xmc.fam.AddMonitor.called) + def test_xdata(self): - config = self.get_config_object() + config = self.get_obj() with self.assertRaises(Bcfg2.Server.Plugin.MetadataRuntimeError): config.xdata config.data = "" self.assertEqual(config.xdata, "") def test_base_xdata(self): - config = self.get_config_object() + config = self.get_obj() # we can't use assertRaises here because base_xdata is a property with self.assertRaises(Bcfg2.Server.Plugin.MetadataRuntimeError): config.base_xdata @@ -193,7 +197,7 @@ class TestXMLMetadataConfig(TestXMLFileBacked): def test_add_monitor(self): core = Mock() - config = self.get_config_object(core=core) + config = self.get_obj(core=core) fname = "test.xml" fpath = os.path.join(self.metadata.data, fname) @@ -203,15 +207,19 @@ class TestXMLMetadataConfig(TestXMLFileBacked): self.assertFalse(core.fam.AddMonitor.called) self.assertEqual(config.extras, [fpath]) - config = self.get_config_object(core=core, watch_clients=True) + config = self.get_obj(core=core, watch_clients=True) config.add_monitor(fpath) core.fam.AddMonitor.assert_called_with(fpath, config.metadata) self.assertItemsEqual(config.extras, [fpath]) + def test_Index(self): + # Index() isn't used on XMLMetadataConfig objects + pass + @patch("Bcfg2.Server.Plugins.Metadata.XMLMetadataConfig.add_monitor") @patch("lxml.etree.parse") def test_load_xml(self, mock_parse, mock_add_monitor): - config = self.get_config_object("clients.xml") + config = self.get_obj("clients.xml") mock_parse.side_effect = lxml.etree.XMLSyntaxError(None, None, None, None) config.load_xml() @@ -243,7 +251,7 @@ class TestXMLMetadataConfig(TestXMLFileBacked): @patch("Bcfg2.Server.Plugins.Metadata.XMLMetadataConfig.write_xml") def test_write(self, mock_write_xml): - config = self.get_config_object("clients.xml") + config = self.get_obj("clients.xml") config.basedata = "" config.write() mock_write_xml.assert_called_with(os.path.join(self.metadata.data, @@ -260,7 +268,7 @@ class TestXMLMetadataConfig(TestXMLFileBacked): def test_write_xml(self, mock_readlink, mock_islink, mock_rename, mock_unlink, mock_open): fname = "clients.xml" - config = self.get_config_object(fname) + config = self.get_obj(fname) fpath = os.path.join(self.metadata.data, fname) tmpfile = "%s.new" % fpath linkdest = os.path.join(self.metadata.data, "client-link.xml") @@ -294,7 +302,7 @@ class TestXMLMetadataConfig(TestXMLFileBacked): @patch("Bcfg2.Server.Plugins.Metadata.XMLMetadataConfig.load_xml", Mock()) @patch('lxml.etree.parse') def test_find_xml_for_xpath(self, mock_parse): - config = self.get_config_object("groups.xml") + config = self.get_obj("groups.xml") config.basedata = self.groups_test_tree xpath = "//Group[@name='group1']" self.assertItemsEqual(config.find_xml_for_xpath(xpath), @@ -324,7 +332,7 @@ class TestXMLMetadataConfig(TestXMLFileBacked): @patch("Bcfg2.Server.Plugins.Metadata.XMLMetadataConfig.load_xml") def test_HandleEvent(self, mock_load_xml): - config = self.get_config_object("groups.xml") + config = self.get_obj("groups.xml") evt = Mock() evt.filename = os.path.join(self.metadata.data, "groups.xml") evt.code2str = Mock(return_value="changed") @@ -340,15 +348,24 @@ class TestClientMetadata(Bcfg2TestCase): self.assertFalse(cm.inGroup("group3")) -class TestMetadata(TestMetadata, TestStatistics, TestDatabaseBacked): +class TestMetadata(_TestMetadata, TestStatistics, TestDatabaseBacked): + test_obj = Metadata groups_test_tree = groups_test_tree clients_test_tree = clients_test_tree use_db = False - def get_metadata_object(self, core=None, watch_clients=False): + def get_obj(self, core=None, watch_clients=False): return get_metadata_object(core=core, watch_clients=watch_clients, use_db=self.use_db) + @unittest.skipUnless(has_django, "Django not found") + def test__use_db(self): + # with the way we've set up our metadata tests, it's unweildy + # to test _use_db. however, given the way get_obj works, if + # there was a bug in _use_db it'd be almost certain to shake + # out in the rest of the testing. + pass + def get_nonexistent_client(self, metadata, prefix="client"): if metadata is None: metadata = self.load_clients_data() @@ -362,7 +379,7 @@ class TestMetadata(TestMetadata, TestStatistics, TestDatabaseBacked): def test__init(self): # test with watch_clients=False core = Mock() - metadata = self.get_metadata_object(core=core) + metadata = self.get_obj(core=core) self.assertIsInstance(metadata, Bcfg2.Server.Plugin.Plugin) self.assertIsInstance(metadata, Bcfg2.Server.Plugin.Metadata) self.assertIsInstance(metadata, Bcfg2.Server.Plugin.Statistics) @@ -373,7 +390,7 @@ class TestMetadata(TestMetadata, TestStatistics, TestDatabaseBacked): # test with watch_clients=True core.fam = Mock() - metadata = self.get_metadata_object(core=core, watch_clients=True) + metadata = self.get_obj(core=core, watch_clients=True) self.assertEqual(len(metadata.states), 2) core.fam.AddMonitor.assert_any_call(os.path.join(metadata.data, "groups.xml"), @@ -385,8 +402,7 @@ class TestMetadata(TestMetadata, TestStatistics, TestDatabaseBacked): core.fam.reset_mock() core.fam.AddMonitor = Mock(side_effect=IOError) self.assertRaises(Bcfg2.Server.Plugin.PluginInitError, - self.get_metadata_object, - core=core, watch_clients=True) + self.get_obj, core=core, watch_clients=True) @patch('os.makedirs', Mock()) @patch('__builtin__.open') @@ -400,21 +416,21 @@ class TestMetadata(TestMetadata, TestStatistics, TestDatabaseBacked): def test_search_xdata(self): # test finding a node with the proper name - metadata = self.get_metadata_object() + metadata = self.get_obj() tree = self.groups_test_tree res = metadata._search_xdata("Group", "group1", tree) self.assertIsInstance(res, lxml.etree._Element) self.assertEqual(res.get("name"), "group1") # test finding a node with the wrong name but correct alias - metadata = self.get_metadata_object() + metadata = self.get_obj() tree = self.clients_test_tree res = metadata._search_xdata("Client", "alias3", tree, alias=True) self.assertIsInstance(res, lxml.etree._Element) self.assertNotEqual(res.get("name"), "alias3") # test failure finding a node - metadata = self.get_metadata_object() + metadata = self.get_obj() tree = self.clients_test_tree res = metadata._search_xdata("Client", self.get_nonexistent_client(metadata), @@ -422,7 +438,7 @@ class TestMetadata(TestMetadata, TestStatistics, TestDatabaseBacked): self.assertIsNone(res) def search_xdata(self, tag, name, tree, alias=False): - metadata = self.get_metadata_object() + metadata = self.get_obj() res = metadata._search_xdata(tag, name, tree, alias=alias) self.assertIsInstance(res, lxml.etree._Element) if not alias: @@ -445,7 +461,7 @@ class TestMetadata(TestMetadata, TestStatistics, TestDatabaseBacked): self.search_xdata("Client", "alias1", tree, alias=True) def test_add_group(self): - metadata = self.get_metadata_object() + metadata = self.get_obj() metadata.groups_xml.write = Mock() metadata.groups_xml.data = lxml.etree.XML('').getroottree() metadata.groups_xml.basedata = copy.copy(metadata.groups_xml.data) @@ -477,7 +493,7 @@ class TestMetadata(TestMetadata, TestStatistics, TestDatabaseBacked): self.assertFalse(metadata.groups_xml.write.called) def test_update_group(self): - metadata = self.get_metadata_object() + metadata = self.get_obj() metadata.groups_xml.write_xml = Mock() metadata.groups_xml.data = copy.deepcopy(self.groups_test_tree) metadata.groups_xml.basedata = copy.copy(metadata.groups_xml.data) @@ -494,7 +510,7 @@ class TestMetadata(TestMetadata, TestStatistics, TestDatabaseBacked): "bogus_group", dict()) def test_remove_group(self): - metadata = self.get_metadata_object() + metadata = self.get_obj() metadata.groups_xml.write_xml = Mock() metadata.groups_xml.data = copy.deepcopy(self.groups_test_tree) metadata.groups_xml.basedata = copy.copy(metadata.groups_xml.data) @@ -509,7 +525,7 @@ class TestMetadata(TestMetadata, TestStatistics, TestDatabaseBacked): "bogus_group") def test_add_bundle(self): - metadata = self.get_metadata_object() + metadata = self.get_obj() metadata.groups_xml.write = Mock() metadata.groups_xml.data = lxml.etree.XML('').getroottree() metadata.groups_xml.basedata = copy.copy(metadata.groups_xml.data) @@ -532,7 +548,7 @@ class TestMetadata(TestMetadata, TestStatistics, TestDatabaseBacked): self.assertFalse(metadata.groups_xml.write.called) def test_remove_bundle(self): - metadata = self.get_metadata_object() + metadata = self.get_obj() metadata.groups_xml.write_xml = Mock() metadata.groups_xml.data = copy.deepcopy(self.groups_test_tree) metadata.groups_xml.basedata = copy.copy(metadata.groups_xml.data) @@ -547,7 +563,7 @@ class TestMetadata(TestMetadata, TestStatistics, TestDatabaseBacked): "bogus_bundle") def test_add_client(self): - metadata = self.get_metadata_object() + metadata = self.get_obj() metadata.clients_xml.write = Mock() metadata.clients_xml.data = lxml.etree.XML('').getroottree() metadata.clients_xml.basedata = copy.copy(metadata.clients_xml.data) @@ -582,7 +598,7 @@ class TestMetadata(TestMetadata, TestStatistics, TestDatabaseBacked): self.assertFalse(metadata.clients_xml.write.called) def test_update_client(self): - metadata = self.get_metadata_object() + metadata = self.get_obj() metadata.clients_xml.write_xml = Mock() metadata.clients_xml.data = copy.deepcopy(self.clients_test_tree) metadata.clients_xml.basedata = copy.copy(metadata.clients_xml.data) @@ -601,7 +617,7 @@ class TestMetadata(TestMetadata, TestStatistics, TestDatabaseBacked): def load_clients_data(self, metadata=None, xdata=None): if metadata is None: - metadata = self.get_metadata_object() + metadata = self.get_obj() metadata.clients_xml.data = \ xdata or copy.deepcopy(self.clients_test_tree) metadata.clients_xml.basedata = copy.copy(metadata.clients_xml.data) @@ -613,7 +629,7 @@ class TestMetadata(TestMetadata, TestStatistics, TestDatabaseBacked): @patch("Bcfg2.Server.Plugins.Metadata.XMLMetadataConfig.load_xml") def test_clients_xml_event(self, mock_load_xml): - metadata = self.get_metadata_object() + metadata = self.get_obj() metadata.profiles = ["group1", "group2"] self.load_clients_data(metadata=metadata) mock_load_xml.assert_any_call() @@ -657,7 +673,7 @@ class TestMetadata(TestMetadata, TestStatistics, TestDatabaseBacked): def load_groups_data(self, metadata=None, xdata=None): if metadata is None: - metadata = self.get_metadata_object() + metadata = self.get_obj() metadata.groups_xml.data = xdata or copy.deepcopy(self.groups_test_tree) metadata.groups_xml.basedata = copy.copy(metadata.groups_xml.data) evt = Mock() @@ -710,7 +726,7 @@ class TestMetadata(TestMetadata, TestStatistics, TestDatabaseBacked): @patch("Bcfg2.Server.Plugins.Metadata.XMLMetadataConfig.load_xml", Mock()) def test_set_profile(self): - metadata = self.get_metadata_object() + metadata = self.get_obj() if 'clients.xml' in metadata.states: metadata.states['clients.xml'] = False self.assertRaises(Bcfg2.Server.Plugin.MetadataRuntimeError, @@ -811,7 +827,7 @@ class TestMetadata(TestMetadata, TestStatistics, TestDatabaseBacked): @patch("Bcfg2.Server.Plugins.Metadata.XMLMetadataConfig.write_xml", Mock()) @patch("Bcfg2.Server.Plugins.Metadata.ClientMetadata") def test_get_initial_metadata(self, mock_clientmetadata): - metadata = self.get_metadata_object() + metadata = self.get_obj() if 'clients.xml' in metadata.states: metadata.states['clients.xml'] = False self.assertRaises(Bcfg2.Server.Plugin.MetadataRuntimeError, @@ -886,7 +902,7 @@ class TestMetadata(TestMetadata, TestStatistics, TestDatabaseBacked): @patch("Bcfg2.Server.Plugins.Metadata.XMLMetadataConfig.load_xml", Mock()) def test_merge_groups(self): - metadata = self.get_metadata_object() + metadata = self.get_obj() self.load_groups_data(metadata=metadata) self.load_clients_data(metadata=metadata) @@ -1113,7 +1129,7 @@ class TestMetadataBase(TestMetadata): def load_clients_data(self, metadata=None, xdata=None): if metadata is None: - metadata = get_metadata_object() + metadata = get_obj() for client in clients_test_tree.findall("Client"): metadata.add_client(client.get("name")) return metadata @@ -1132,7 +1148,7 @@ class TestMetadataBase(TestMetadata): core = Mock() core.fam = Mock() mock_exists.return_value = False - metadata = self.get_metadata_object(core=core, watch_clients=True) + metadata = self.get_obj(core=core, watch_clients=True) self.assertIsInstance(metadata, Bcfg2.Server.Plugin.DatabaseBacked) core.fam.AddMonitor.assert_called_once_with(os.path.join(metadata.data, "groups.xml"), @@ -1140,7 +1156,7 @@ class TestMetadataBase(TestMetadata): mock_exists.return_value = True core.fam.reset_mock() - metadata = self.get_metadata_object(core=core, watch_clients=True) + metadata = self.get_obj(core=core, watch_clients=True) core.fam.AddMonitor.assert_any_call(os.path.join(metadata.data, "groups.xml"), metadata) @@ -1155,7 +1171,7 @@ class TestMetadataBase(TestMetadata): pass def test_add_client(self): - metadata = self.get_metadata_object() + metadata = self.get_obj() hostname = self.get_nonexistent_client(metadata) client = metadata.add_client(hostname) self.assertIsInstance(client, MetadataClientModel) @@ -1176,7 +1192,7 @@ class TestMetadataBase(TestMetadata): pass def test_list_clients(self): - metadata = self.get_metadata_object() + metadata = self.get_obj() self.assertItemsEqual(metadata.list_clients(), [c.hostname for c in MetadataClientModel.objects.all()]) @@ -1188,7 +1204,7 @@ class TestMetadataBase(TestMetadata): pass def test_remove_client(self): - metadata = self.get_metadata_object() + metadata = self.get_obj() client_name = self.get_nonexistent_client(metadata) self.assertRaises(Bcfg2.Server.Plugin.MetadataConsistencyError, @@ -1225,7 +1241,7 @@ class TestMetadata_NoClientsXML(TestMetadataBase): @patch("Bcfg2.Server.Plugins.Metadata.XMLMetadataConfig.write_xml", Mock()) @patch("Bcfg2.Server.Plugins.Metadata.ClientMetadata") def test_get_initial_metadata(self, mock_clientmetadata): - metadata = self.get_metadata_object() + metadata = self.get_obj() if 'clients.xml' in metadata.states: metadata.states['clients.xml'] = False self.assertRaises(Bcfg2.Server.Plugin.MetadataRuntimeError, @@ -1364,7 +1380,7 @@ class TestMetadata_ClientsXML(TestMetadataBase): def load_clients_data(self, metadata=None, xdata=None): if metadata is None: - metadata = self.get_metadata_object() + metadata = self.get_obj() metadata.core.fam = Mock() metadata._handle_file("clients.xml") metadata = TestMetadata.load_clients_data(self, metadata=metadata, @@ -1377,7 +1393,7 @@ class TestMetadata_ClientsXML(TestMetadataBase): @patch("Bcfg2.Server.Plugins.Metadata.Metadata.list_clients") def test_clients_xml_event(self, mock_list_clients, mock_handle_event, mock_load_xml): - metadata = self.get_metadata_object() + metadata = self.get_obj() metadata.profiles = ["group1", "group2"] evt = Mock() evt.filename = os.path.join(datastore, "Metadata", "clients.xml") diff --git a/testsuite/Testlib/TestServer/TestPlugins/TestProbes.py b/testsuite/Testlib/TestServer/TestPlugins/TestProbes.py index 816f9c370..f90096210 100644 --- a/testsuite/Testlib/TestServer/TestPlugins/TestProbes.py +++ b/testsuite/Testlib/TestServer/TestPlugins/TestProbes.py @@ -74,19 +74,22 @@ class TestProbeData(Bcfg2TestCase): class TestProbeSet(TestEntrySet): - def get_probeset_object(self, fam=None): + test_obj = ProbeSet + + def get_obj(self, path=datastore, fam=None, encoding=None, + plugin_name="Probes"): if fam is None: fam = Mock() - return ProbeSet(datastore, fam, None, "Probes") + return self.test_obj(path, fam, encoding, plugin_name) def test__init(self): fam = Mock() - ps = self.get_probeset_object(fam) + ps = self.get_obj(fam=fam) self.assertEqual(ps.plugin_name, "Probes") fam.AddMonitor.assert_called_with(datastore, ps) def test_HandleEvent(self): - ps = self.get_probeset_object() + ps = self.get_obj() ps.handle_event = Mock() # test that events on the data store itself are skipped @@ -109,7 +112,7 @@ class TestProbeSet(TestEntrySet): @patch("__builtin__.list", FakeList) def test_get_probe_data(self): - ps = self.get_probeset_object() + ps = self.get_obj() # build some fairly complex test data for this. in the end, # we want the probe data to include only the most specific @@ -170,6 +173,8 @@ group-specific""" class TestProbes(TestProbing, TestConnector, TestDatabaseBacked): + test_obj = Probes + def get_test_probedata(self): test_xdata = lxml.etree.Element("test") lxml.etree.SubElement(test_xdata, "test", foo="foo") -- cgit v1.2.3-1-g7c22 From ed48c3c7cd7da8fac30a791ce2495706b6fa3876 Mon Sep 17 00:00:00 2001 From: "Chris St. Pierre" Date: Tue, 14 Aug 2012 09:45:12 -0400 Subject: added tests for PrioDir --- testsuite/Testlib/TestServer/TestPlugin.py | 159 +++++++++++++++++++++++------ 1 file changed, 125 insertions(+), 34 deletions(-) (limited to 'testsuite') diff --git a/testsuite/Testlib/TestServer/TestPlugin.py b/testsuite/Testlib/TestServer/TestPlugin.py index 5c3c98502..1939b90d3 100644 --- a/testsuite/Testlib/TestServer/TestPlugin.py +++ b/testsuite/Testlib/TestServer/TestPlugin.py @@ -504,42 +504,41 @@ class TestDirectoryBacked(Bcfg2TestCase): @patch("os.path.isdir") def test_add_directory_monitor(self, mock_isdir): - fam = Mock() - fam.rv = 0 - db = self.get_obj(fam=fam) + db = self.get_obj() + db.fam = Mock() + db.fam.rv = 0 def reset(): - fam.rv += 1 - fam.AddMonitor.return_value = fam.rv - fam.reset_mock() + db.fam.rv += 1 + db.fam.AddMonitor.return_value = db.fam.rv + db.fam.reset_mock() mock_isdir.reset_mock() mock_isdir.return_value = True for path in self.testpaths.values(): reset() db.add_directory_monitor(path) - fam.AddMonitor.assert_called_with(os.path.join(datastore, - path), - db) - self.assertIn(fam.rv, db.handles) - self.assertEqual(db.handles[fam.rv], path) + db.fam.AddMonitor.assert_called_with(os.path.join(db.data, path), + db) + self.assertIn(db.fam.rv, db.handles) + self.assertEqual(db.handles[db.fam.rv], path) reset() # test duplicate adds for path in self.testpaths.values(): reset() db.add_directory_monitor(path) - self.assertFalse(fam.AddMonitor.called) + self.assertFalse(db.fam.AddMonitor.called) reset() mock_isdir.return_value = False db.add_directory_monitor('bogus') - self.assertFalse(fam.AddMonitor.called) - self.assertNotIn(fam.rv, db.handles) + self.assertFalse(db.fam.AddMonitor.called) + self.assertNotIn(db.fam.rv, db.handles) def test_add_entry(self): - fam = Mock() - db = self.get_obj(fam=fam) + db = self.get_obj() + db.fam = Mock() class MockChild(Mock): def __init__(self, path, fam, **kwargs): Mock.__init__(self, **kwargs) @@ -553,16 +552,15 @@ class TestDirectoryBacked(Bcfg2TestCase): db.add_entry(path, event) self.assertIn(path, db.entries) self.assertEqual(db.entries[path].path, - os.path.join(datastore, path)) - self.assertEqual(db.entries[path].fam, fam) + os.path.join(db.data, path)) + self.assertEqual(db.entries[path].fam, db.fam) db.entries[path].HandleEvent.assert_called_with(event) @patch("os.path.isdir") @patch("Bcfg2.Server.Plugin.%s.add_entry" % test_obj.__name__) @patch("Bcfg2.Server.Plugin.%s.add_directory_monitor" % test_obj.__name__) def test_HandleEvent(self, mock_add_monitor, mock_add_entry, mock_isdir): - fam = Mock() - db = self.get_obj(fam=fam) + db = self.get_obj() # a path with a leading / should never get into # DirectoryBacked.handles, so strip that test case for rid, path in self.testpaths.items(): @@ -570,7 +568,6 @@ class TestDirectoryBacked(Bcfg2TestCase): db.handles[rid] = path def reset(): - fam.reset_mock() mock_isdir.reset_mock() mock_add_entry.reset_mock() mock_add_monitor.reset_mock() @@ -622,7 +619,7 @@ class TestDirectoryBacked(Bcfg2TestCase): db.HandleEvent(event) mock_add_entry.assert_called_with(relpath, event) self.assertFalse(mock_add_monitor.called) - db.entries[relpath] = Mock() + db.entries[relpath] = MagicMock() # test that changing a file that already exists works reset() @@ -644,7 +641,7 @@ class TestDirectoryBacked(Bcfg2TestCase): db.HandleEvent(event) mock_add_entry.assert_called_with(relpath, event) self.assertFalse(mock_add_monitor.called) - db.entries[relpath] = Mock() + db.entries[relpath] = MagicMock() # test that deleting a directory works. this is a little # strange because the _parent_ directory has to handle the @@ -1399,25 +1396,119 @@ class TestXMLDirectoryBacked(TestDirectoryBacked): class TestPrioDir(TestPlugin, TestGenerator, TestXMLDirectoryBacked): test_obj = PrioDir + @patch("Bcfg2.Server.Plugin.%s.add_directory_monitor" % test_obj.__name__, + Mock()) def get_obj(self, core=None): if core is None: core = Mock() return self.test_obj(core, datastore) def test_HandleEvent(self): - pass - - def test__iter(self): - pass - - def test__getitem(self): - pass + TestXMLDirectoryBacked.test_HandleEvent(self) + with patch("Bcfg2.Server.Plugin.XMLDirectoryBacked.HandleEvent"): + pd = self.get_obj() + test1 = Mock() + test1.items = dict(Path=["/etc/foo.conf", "/etc/bar.conf"]) + test2 = Mock() + test2.items = dict(Path=["/etc/baz.conf"], + Package=["quux", "xyzzy"]) + pd.entries = {"/test1.xml": test1, + "/test2.xml": test2} + pd.HandleEvent(Mock()) + self.assertItemsEqual(pd.Entries, + dict(Path={"/etc/foo.conf": pd.BindEntry, + "/etc/bar.conf": pd.BindEntry, + "/etc/baz.conf": pd.BindEntry}, + Package={"quux": pd.BindEntry, + "xyzzy": pd.BindEntry})) + + def test__matches(self): + pd = self.get_obj() + self.assertTrue(pd._matches(lxml.etree.Element("Test", + name="/etc/foo.conf"), + Mock(), + {"/etc/foo.conf": pd.BindEntry, + "/etc/bar.conf": pd.BindEntry})) + self.assertFalse(pd._matches(lxml.etree.Element("Test", + name="/etc/baz.conf"), + Mock(), + {"/etc/foo.conf": pd.BindEntry, + "/etc/bar.conf": pd.BindEntry})) + + def test_BindEntry(self): + pd = self.get_obj() + pd.get_attrs = Mock(return_value=dict(test1="test1", test2="test2")) + entry = lxml.etree.Element("Path", name="/etc/foo.conf", test1="bogus") + metadata = Mock() + pd.BindEntry(entry, metadata) + pd.get_attrs.assert_called_with(entry, metadata) + self.assertItemsEqual(entry.attrib, + dict(name="/etc/foo.conf", + test1="test1", test2="test2")) + + def test_get_attrs(self): + pd = self.get_obj() + entry = lxml.etree.Element("Path", name="/etc/foo.conf") + children = [lxml.etree.Element("Child")] + metadata = Mock() + pd.entries = dict() - def test_add_entry(self): - pass + def reset(): + metadata.reset_mock() + for src in pd.entries.values(): + src.reset_mock() + src.cache = None - def test_add_directory_monitor(self): - pass + # test with no matches + self.assertRaises(PluginExecutionError, + pd.get_attrs, entry, metadata) + + def add_entry(name, data, prio=10): + path = os.path.join(pd.data, name) + pd.entries[path] = Mock() + pd.entries[path].priority = prio + def do_Cache(metadata): + pd.entries[path].cache = (metadata, data) + pd.entries[path].Cache.side_effect = do_Cache + + add_entry('test1.xml', + dict(Path={'/etc/foo.conf': dict(attr="attr1", + __children__=children), + '/etc/bar.conf': dict()})) + add_entry('test2.xml', + dict(Path={'/etc/bar.conf': dict(__text__="text", + attr="attr1")}, + Package={'quux': dict(), + 'xyzzy': dict()}), + prio=20) + add_entry('test3.xml', + dict(Path={'/etc/baz.conf': dict()}, + Package={'xyzzy': dict()}), + prio=20) + + # test with exactly one match, __children__ + reset() + self.assertItemsEqual(pd.get_attrs(entry, metadata), + dict(attr="attr1")) + for src in pd.entries.values(): + src.Cache.assert_called_with(metadata) + self.assertEqual(len(entry.getchildren()), 1) + self.assertXMLEqual(entry.getchildren()[0], children[0]) + + # test with multiple matches with different priorities, __text__ + reset() + entry = lxml.etree.Element("Path", name="/etc/bar.conf") + self.assertItemsEqual(pd.get_attrs(entry, metadata), + dict(attr="attr1")) + for src in pd.entries.values(): + src.Cache.assert_called_with(metadata) + self.assertEqual(entry.text, "text") + + # test with multiple matches with identical priorities + reset() + entry = lxml.etree.Element("Package", name="xyzzy") + self.assertRaises(PluginExecutionError, + pd.get_attrs, entry, metadata) class SpecificityError(Bcfg2TestCase): -- cgit v1.2.3-1-g7c22 From 554022ae751777a6f853f54663dc5e9fab818dce Mon Sep 17 00:00:00 2001 From: "Chris St. Pierre" Date: Tue, 14 Aug 2012 11:02:50 -0400 Subject: added tests for Specificity/SpecificData --- testsuite/Testlib/TestServer/TestPlugin.py | 86 +++++++++++++++++++++++++++++- 1 file changed, 84 insertions(+), 2 deletions(-) (limited to 'testsuite') diff --git a/testsuite/Testlib/TestServer/TestPlugin.py b/testsuite/Testlib/TestServer/TestPlugin.py index 1939b90d3..9ca3243a3 100644 --- a/testsuite/Testlib/TestServer/TestPlugin.py +++ b/testsuite/Testlib/TestServer/TestPlugin.py @@ -1517,11 +1517,93 @@ class SpecificityError(Bcfg2TestCase): class Specificity(Bcfg2TestCase): - pass + test_obj = Specificity + + def get_obj(self, **kwargs): + return self.test_obj(**kwargs) + + def test_matches(self): + metadata = Mock() + metadata.hostname = "foo.example.com" + metadata.groups = ["group1", "group2"] + self.assertTrue(self.get_obj(all=True).matches(metadata)) + self.assertTrue(self.get_obj(group="group1").matches(metadata)) + self.assertTrue(self.get_obj(hostname="foo.example.com").matches(metadata)) + self.assertFalse(self.get_obj().matches(metadata)) + self.assertFalse(self.get_obj(group="group3").matches(metadata)) + self.assertFalse(self.get_obj(hostname="bar.example.com").matches(metadata)) + + def test__cmp(self): + specs = [self.get_obj(all=True), + self.get_obj(group="group1", prio=10), + self.get_obj(group="group1", prio=20), + self.get_obj(hostname="foo.example.com")] + + for i in range(len(specs)): + for j in range(len(specs)): + if i == j: + self.assertEqual(0, specs[i].__cmp__(specs[j])) + self.assertEqual(0, specs[j].__cmp__(specs[i])) + elif i > j: + self.assertEqual(-1, specs[i].__cmp__(specs[j])) + self.assertEqual(1, specs[j].__cmp__(specs[i])) + elif i < j: + self.assertEqual(1, specs[i].__cmp__(specs[j])) + self.assertEqual(-1, specs[j].__cmp__(specs[i])) + + def test_cmp(self): + """ test __lt__/__gt__/__eq__ """ + specs = [self.get_obj(all=True), + self.get_obj(group="group1", prio=10), + self.get_obj(group="group1", prio=20), + self.get_obj(hostname="foo.example.com")] + + for i in range(len(specs)): + for j in range(len(specs)): + print "i=%s, j=%s" % (i, j) + if i < j: + self.assertGreater(specs[i], specs[j]) + self.assertLess(specs[j], specs[i]) + self.assertGreaterEqual(specs[i], specs[j]) + self.assertLessEqual(specs[j], specs[i]) + elif i == j: + self.assertEqual(specs[i], specs[j]) + self.assertEqual(specs[j], specs[i]) + self.assertLessEqual(specs[i], specs[j]) + self.assertGreaterEqual(specs[j], specs[i]) + elif i > j: + self.assertLess(specs[i], specs[j]) + self.assertGreater(specs[j], specs[i]) + self.assertLessEqual(specs[i], specs[j]) + self.assertGreaterEqual(specs[j], specs[i]) class SpecificData(Bcfg2TestCase): - pass + test_obj = SpecificData + + def get_obj(self, name="/test.txt", specific=None, encoding=None): + if specific is None: + specific = Mock() + return self.test_obj(name, specific, encoding) + + @patch("__builtin__.open") + def test_handle_event(self, mock_open): + event = Mock() + event.code2str.return_value = 'deleted' + sd = self.get_obj() + sd.handle_event(event) + self.assertFalse(mock_open.called) + if hasattr(sd, 'data'): + self.assertIsNone(sd.data) + else: + self.assertFalse(hasattr(sd, 'data')) + + event = Mock() + mock_open.return_value.read.return_value = "test" + sd.handle_event(event) + mock_open.assert_called_with("/test.txt") + mock_open.return_value.read.assert_any_call() + self.assertEqual(sd.data, "test") class TestEntrySet(TestDebuggable): -- cgit v1.2.3-1-g7c22 From be4f6ad065fa17ae34c810f2c09bc9f5fa4d9c23 Mon Sep 17 00:00:00 2001 From: "Chris St. Pierre" Date: Tue, 14 Aug 2012 14:44:08 -0400 Subject: added unit tests for EntrySet --- testsuite/Testlib/TestServer/TestPlugin.py | 399 ++++++++++++++++++++- .../Testlib/TestServer/TestPlugins/TestProbes.py | 15 +- 2 files changed, 397 insertions(+), 17 deletions(-) (limited to 'testsuite') diff --git a/testsuite/Testlib/TestServer/TestPlugin.py b/testsuite/Testlib/TestServer/TestPlugin.py index 9ca3243a3..e5baf9a0b 100644 --- a/testsuite/Testlib/TestServer/TestPlugin.py +++ b/testsuite/Testlib/TestServer/TestPlugin.py @@ -1,4 +1,5 @@ import os +import re import copy import logging import unittest @@ -164,32 +165,39 @@ class TestPluginDatabaseModel(Bcfg2TestCase): class TestGenerator(Bcfg2TestCase): - def test_HandleEntry(self): - g = Generator() - self.assertRaises(NotImplementedError, - g.HandleEntry, None, None) + test_obj = Generator class TestStructure(Bcfg2TestCase): + test_obj = Structure + + def get_obj(self): + return self.test_obj() + def test_BuildStructures(self): - s = Structure() + s = self.get_obj() self.assertRaises(NotImplementedError, s.BuildStructures, None) class TestMetadata(Bcfg2TestCase): + test_obj = Metadata + + def get_obj(self): + return self.test_obj() + def test_get_initial_metadata(self): - m = Metadata() + m = self.get_obj() self.assertRaises(NotImplementedError, m.get_initial_metadata, None) def test_merge_additional_data(self): - m = Metadata() + m = self.get_obj() self.assertRaises(NotImplementedError, m.merge_additional_data, None, None, None) def test_merge_additional_groups(self): - m = Metadata() + m = self.get_obj() self.assertRaises(NotImplementedError, m.merge_additional_groups, None, None) @@ -1511,12 +1519,12 @@ class TestPrioDir(TestPlugin, TestGenerator, TestXMLDirectoryBacked): pd.get_attrs, entry, metadata) -class SpecificityError(Bcfg2TestCase): +class TestSpecificityError(Bcfg2TestCase): """ placeholder for future tests """ pass -class Specificity(Bcfg2TestCase): +class TestSpecificity(Bcfg2TestCase): test_obj = Specificity def get_obj(self, **kwargs): @@ -1560,7 +1568,6 @@ class Specificity(Bcfg2TestCase): for i in range(len(specs)): for j in range(len(specs)): - print "i=%s, j=%s" % (i, j) if i < j: self.assertGreater(specs[i], specs[j]) self.assertLess(specs[j], specs[i]) @@ -1578,7 +1585,7 @@ class Specificity(Bcfg2TestCase): self.assertGreaterEqual(specs[j], specs[i]) -class SpecificData(Bcfg2TestCase): +class TestSpecificData(Bcfg2TestCase): test_obj = SpecificData def get_obj(self, name="/test.txt", specific=None, encoding=None): @@ -1608,12 +1615,376 @@ class SpecificData(Bcfg2TestCase): class TestEntrySet(TestDebuggable): test_obj = EntrySet + # filenames that should be matched successfully by the EntrySet + # 'specific' regex. these are filenames alone -- a specificity + # will be added to these + basenames = ["test", "test.py", "test with spaces.txt", + "test.multiple.dots.py", "test_underscores.and.dots", + "really_misleading.G10_test", + "name$with*regex(special){chars}", + "misleading.H_hostname.test.com"] + # filenames that do not match any of the basenames (or the + # basename regex, if applicable) + bogus_names = ["bogus"] + # filenames that should be ignored + 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=SpecificData, + def get_obj(self, basename="test", path=datastore, entry_type=MagicMock(), encoding=None): return self.test_obj(basename, path, entry_type, encoding) + def test__init(self): + for basename in self.basenames: + eset = self.get_obj(basename=basename) + self.assertIsInstance(eset.specific, re._pattern_type) + self.assertTrue(eset.specific.match(os.path.join(datastore, + basename))) + ppath = os.path.join(datastore, "Plugin", basename) + self.assertTrue(eset.specific.match(ppath)) + self.assertTrue(eset.specific.match(ppath + ".G20_foo")) + self.assertTrue(eset.specific.match(ppath + ".G1_foo")) + self.assertTrue(eset.specific.match(ppath + ".G32768_foo")) + # a group named '_' + self.assertTrue(eset.specific.match(ppath + ".G10__")) + self.assertTrue(eset.specific.match(ppath + ".H_hostname")) + self.assertTrue(eset.specific.match(ppath + ".H_fqdn.subdomain.example.com")) + self.assertTrue(eset.specific.match(ppath + ".G20_group_with_underscores")) + + self.assertFalse(eset.specific.match(ppath + ".G20_group with spaces")) + self.assertFalse(eset.specific.match(ppath + ".G_foo")) + self.assertFalse(eset.specific.match(ppath + ".G_")) + self.assertFalse(eset.specific.match(ppath + ".G20_")) + self.assertFalse(eset.specific.match(ppath + ".H_")) + + for bogus in self.bogus_names: + self.assertFalse(eset.specific.match(os.path.join(datastore, + "Plugin", + bogus))) + + for ignore in self.ignore: + self.assertTrue(eset.ignore.match(ignore)) + + self.assertFalse(eset.ignore.match(basename)) + self.assertFalse(eset.ignore.match(basename + ".G20_foo")) + self.assertFalse(eset.ignore.match(basename + ".G1_foo")) + self.assertFalse(eset.ignore.match(basename + ".G32768_foo")) + self.assertFalse(eset.ignore.match(basename + ".G10__")) + self.assertFalse(eset.ignore.match(basename + ".H_hostname")) + self.assertFalse(eset.ignore.match(basename + ".H_fqdn.subdomain.example.com")) + self.assertFalse(eset.ignore.match(basename + ".G20_group_with_underscores")) + + def test_get_matching(self): + items = {0: Mock(), 1: Mock(), 2: Mock(), 3: Mock(), 4: Mock(), + 5: Mock()} + items[0].specific.matches.return_value = False + items[1].specific.matches.return_value = True + items[2].specific.matches.return_value = False + items[3].specific.matches.return_value = False + items[4].specific.matches.return_value = True + items[5].specific.matches.return_value = True + metadata = Mock() + eset = self.get_obj() + eset.entries = items + self.assertItemsEqual(eset.get_matching(metadata), + [items[1], items[4], items[5]]) + for i in items.values(): + i.specific.matches.assert_called_with(metadata) + + @patch("Bcfg2.Server.Plugin.%s.get_matching" % test_obj.__name__) + def test_best_matching(self, mock_get_matching): + eset = self.get_obj() + metadata = Mock() + matching = [] + + def reset(): + mock_get_matching.reset_mock() + metadata.reset_mock() + for m in matching: + m.reset_mock() + + def specific(all=False, group=False, prio=None, host=False): + spec = MagicMock() + spec.all = all + spec.group = group + spec.prio = prio + spec.host = host + if prio: + spec.__cmp__ = lambda o: cmp(spec.prio, o.prio) + return spec + + self.assertRaises(PluginExecutionError, + eset.best_matching, metadata, matching=[]) + + reset() + mock_get_matching.return_value = matching + self.assertRaises(PluginExecutionError, + eset.best_matching, metadata) + mock_get_matching.assert_called_with(metadata) + + # test with a single file for all + reset() + matching.insert(0, specific(all=True)) + mock_get_matching.return_value = matching + self.assertEqual(eset.best_matching(metadata), + matching[0]) + mock_get_matching.assert_called_with(metadata) + + # test with a single group-specific file + reset() + matching.insert(0, specific(group=True, prio=10)) + mock_get_matching.return_value = matching + self.assertEqual(eset.best_matching(metadata), + matching[0]) + mock_get_matching.assert_called_with(metadata) + + # test with multiple group-specific files + reset() + matching.insert(0, specific(group=True, prio=20)) + mock_get_matching.return_value = matching + self.assertEqual(eset.best_matching(metadata), + matching[0]) + mock_get_matching.assert_called_with(metadata) + + # test with host-specific file + reset() + matching.insert(0, specific(host=True)) + mock_get_matching.return_value = matching + self.assertEqual(eset.best_matching(metadata), + matching[0]) + mock_get_matching.assert_called_with(metadata) + + @patch("Bcfg2.Server.Plugin.%s.entry_init" % test_obj.__name__) + @patch("Bcfg2.Server.Plugin.%s.reset_metadata" % test_obj.__name__) + @patch("Bcfg2.Server.Plugin.%s.update_metadata" % test_obj.__name__) + def test_handle_event(self, mock_update_md, mock_reset_md, mock_init): + def reset(): + mock_update_md.reset_mock() + mock_reset_md.reset_mock() + mock_init.reset_mock() + + eset = self.get_obj() + for fname in ["info", "info.xml", ":info"]: + for evt in ["exists", "created", "changed"]: + reset() + event = Mock() + event.code2str.return_value = evt + event.filename = fname + eset.handle_event(event) + mock_update_md.assert_called_with(event) + self.assertFalse(mock_init.called) + self.assertFalse(mock_reset_md.called) + + reset() + event = Mock() + event.code2str.return_value = "deleted" + event.filename = fname + eset.handle_event(event) + mock_reset_md.assert_called_with(event) + self.assertFalse(mock_init.called) + self.assertFalse(mock_update_md.called) + + for evt in ["exists", "created", "changed"]: + reset() + event = Mock() + event.code2str.return_value = evt + event.filename = "test.txt" + eset.handle_event(event) + mock_init.assert_called_with(event) + self.assertFalse(mock_reset_md.called) + self.assertFalse(mock_update_md.called) + + reset() + entry = Mock() + eset.entries["test.txt"] = entry + event = Mock() + event.code2str.return_value = "changed" + event.filename = "test.txt" + eset.handle_event(event) + entry.handle_event.assert_called_with(event) + self.assertFalse(mock_init.called) + self.assertFalse(mock_reset_md.called) + self.assertFalse(mock_update_md.called) + + reset() + entry = Mock() + eset.entries["test.txt"] = entry + event = Mock() + event.code2str.return_value = "deleted" + event.filename = "test.txt" + eset.handle_event(event) + self.assertNotIn("test.txt", eset.entries) + + @patch("Bcfg2.Server.Plugin.%s.specificity_from_filename" % + test_obj.__name__) + def test_entry_init(self, mock_spec): + eset = self.get_obj() + + def reset(): + eset.entry_type.reset_mock() + mock_spec.reset_mock() + + event = Mock() + event.code2str.return_value = "created" + event.filename = "test.txt" + eset.entry_init(event) + mock_spec.assert_called_with("test.txt", specific=None) + eset.entry_type.assert_called_with(os.path.join(eset.path, "test.txt"), + mock_spec.return_value, None) + eset.entry_type.return_value.handle_event.assert_called_with(event) + self.assertIn("test.txt", eset.entries) + + # test duplicate add + reset() + eset.entry_init(event) + self.assertFalse(mock_spec.called) + self.assertFalse(eset.entry_type.called) + eset.entries["test.txt"].handle_event.assert_called_with(event) + + # test keyword args + etype = Mock() + specific = Mock() + event = Mock() + event.code2str.return_value = "created" + event.filename = "test2.txt" + eset.entry_init(event, entry_type=etype, specific=specific) + mock_spec.assert_called_with("test2.txt", specific=specific) + etype.assert_called_with(os.path.join(eset.path, "test2.txt"), + mock_spec.return_value, None) + etype.return_value.handle_event.assert_called_with(event) + self.assertIn("test2.txt", eset.entries) + + # test specificity error + event = Mock() + event.code2str.return_value = "created" + event.filename = "test3.txt" + mock_spec.side_effect = SpecificityError + eset.entry_init(event) + mock_spec.assert_called_with("test3.txt", specific=None) + self.assertFalse(eset.entry_type.called) + + @patch("Bcfg2.Server.Plugin.Specificity") + def test_specificity_from_filename(self, mock_spec): + def test(eset, fname, **kwargs): + mock_spec.reset_mock() + if "specific" in kwargs: + specific = kwargs['specific'] + del kwargs['specific'] + else: + specific = None + self.assertEqual(eset.specificity_from_filename(fname, + specific=specific), + mock_spec.return_value) + mock_spec.assert_called_with(**kwargs) + + def fails(eset, fname, specific=None): + mock_spec.reset_mock() + self.assertRaises(SpecificityError, + eset.specificity_from_filename, fname, + specific=specific) + + for basename in self.basenames: + eset = self.get_obj(basename=basename) + ppath = os.path.join(datastore, "Plugin", basename) + test(eset, ppath, all=True) + test(eset, ppath + ".G20_foo", group="foo", prio=20) + test(eset, ppath + ".G1_foo", group="foo", prio=1) + test(eset, ppath + ".G32768_foo", group="foo", prio=32768) + test(eset, ppath + ".G10__", group="_", prio=10) + test(eset, ppath + ".H_hostname", hostname="hostname") + test(eset, ppath + ".H_fqdn.subdomain.example.com", + hostname="fqdn.subdomain.example.com") + test(eset, ppath + ".G20_group_with_underscores", + group="group_with_underscores", prio=20) + + for bogus in self.bogus_names: + fails(eset, bogus) + fails(eset, ppath + ".G_group with spaces") + fails(eset, ppath + ".G_foo") + fails(eset, ppath + ".G_") + fails(eset, ppath + ".G20_") + fails(eset, ppath + ".H_") + + @patch("__builtin__.open") + @patch("Bcfg2.Server.Plugin.InfoXML") + def test_update_metadata(self, mock_InfoXML, mock_open): + eset = self.get_obj() + + # add info.xml + event = Mock() + event.filename = "info.xml" + eset.update_metadata(event) + mock_InfoXML.assert_called_with(os.path.join(eset.path, "info.xml"), + True) + mock_InfoXML.return_value.HandleEvent.assert_called_with(event) + self.assertEqual(eset.infoxml, mock_InfoXML.return_value) + + # modify info.xml + mock_InfoXML.reset_mock() + eset.update_metadata(event) + self.assertFalse(mock_InfoXML.called) + eset.infoxml.HandleEvent.assert_called_with(event) + + for fname in [':info', 'info']: + event = Mock() + event.filename = fname + + idata = ["owner:owner", + "group: GROUP", + "perms: 775", + "important: true", + "bogus: line"] + mock_open.return_value.readlines.return_value = idata + eset.update_metadata(event) + expected = default_file_metadata.copy() + expected['owner'] = 'owner' + expected['group'] = 'GROUP' + expected['perms'] = '0775' + expected['important'] = 'true' + self.assertItemsEqual(eset.metadata, + expected) + + def test_reset_metadata(self): + eset = self.get_obj() + + # test info.xml + event = Mock() + event.filename = "info.xml" + eset.infoxml = Mock() + eset.reset_metadata(event) + self.assertIsNone(eset.infoxml) + + for fname in [':info', 'info']: + event = Mock() + event.filename = fname + eset.metadata = Mock() + eset.reset_metadata(event) + self.assertItemsEqual(eset.metadata, default_file_metadata) + + @patch("Bcfg2.Server.Plugin.bind_info") + def test_bind_info_to_entry(self, mock_bind_info): + eset = self.get_obj() + entry = Mock() + metadata = Mock() + eset.bind_info_to_entry(entry, metadata) + mock_bind_info.assert_called_with(entry, metadata, + infoxml=eset.infoxml, + default=eset.metadata) + + @patch("Bcfg2.Server.Plugin.%s.best_matching" % test_obj.__name__) + @patch("Bcfg2.Server.Plugin.%s.bind_info_to_entry" % test_obj.__name__) + def test_bind_entry(self, mock_bind_info, mock_best_matching): + eset = self.get_obj() + entry = Mock() + metadata = Mock() + eset.bind_entry(entry, metadata) + mock_bind_info.assert_called_with(entry, metadata) + mock_best_matching.assert_called_with(metadata) + mock_best_matching.return_value.bind_entry.assert_called_with(entry, + metadata) + -class GroupSpool(TestPlugin, TestGenerator): +class TestGroupSpool(TestPlugin, TestGenerator): test_obj = GroupSpool pass diff --git a/testsuite/Testlib/TestServer/TestPlugins/TestProbes.py b/testsuite/Testlib/TestServer/TestPlugins/TestProbes.py index f90096210..0bcb65dc4 100644 --- a/testsuite/Testlib/TestServer/TestPlugins/TestProbes.py +++ b/testsuite/Testlib/TestServer/TestPlugins/TestProbes.py @@ -3,7 +3,7 @@ import sys import time import unittest import lxml.etree -from mock import Mock, patch +from mock import Mock, MagicMock, patch from ....common import * import Bcfg2.Server import Bcfg2.Server.Plugin @@ -75,18 +75,27 @@ class TestProbeData(Bcfg2TestCase): class TestProbeSet(TestEntrySet): test_obj = ProbeSet + basenames = ["test", "_test", "test-test"] + ignore = ["foo~", ".#foo", ".foo.swp", ".foo.swx", "probed.xml"] + bogus_names = ["test.py"] def get_obj(self, path=datastore, fam=None, encoding=None, - plugin_name="Probes"): + plugin_name="Probes", basename=None): + # 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" if fam is None: fam = Mock() - return self.test_obj(path, fam, encoding, plugin_name) + rv = self.test_obj(path, fam, encoding, plugin_name) + rv.entry_type = MagicMock() + return rv def test__init(self): fam = Mock() ps = self.get_obj(fam=fam) self.assertEqual(ps.plugin_name, "Probes") fam.AddMonitor.assert_called_with(datastore, ps) + TestEntrySet.test__init(self) def test_HandleEvent(self): ps = self.get_obj() -- cgit v1.2.3-1-g7c22 From 8207c9c78a94d316bfbd582b2672796e488319b5 Mon Sep 17 00:00:00 2001 From: "Chris St. Pierre" Date: Wed, 15 Aug 2012 08:17:35 -0400 Subject: added tests for GroupSpool --- testsuite/Testlib/TestServer/TestPlugin.py | 195 ++++++++++++++++++++++++++++- 1 file changed, 194 insertions(+), 1 deletion(-) (limited to 'testsuite') diff --git a/testsuite/Testlib/TestServer/TestPlugin.py b/testsuite/Testlib/TestServer/TestPlugin.py index e5baf9a0b..3cfe0ca42 100644 --- a/testsuite/Testlib/TestServer/TestPlugin.py +++ b/testsuite/Testlib/TestServer/TestPlugin.py @@ -1987,4 +1987,197 @@ class TestEntrySet(TestDebuggable): class TestGroupSpool(TestPlugin, TestGenerator): test_obj = GroupSpool - pass + + @patch("Bcfg2.Server.Plugin.%s.AddDirectoryMonitor" % test_obj.__name__) + def get_obj(self, core=None): + return TestPlugin.get_obj(self, core=core) + + @patch("Bcfg2.Server.Plugin.%s.AddDirectoryMonitor" % test_obj.__name__) + def test__init(self, mock_Add): + core = Mock() + gs = self.test_obj(core, datastore) + mock_Add.assert_called_with('') + self.assertItemsEqual(gs.Entries, {gs.entry_type: {}}) + + @patch("os.path.isdir") + @patch("os.path.isfile") + @patch("Bcfg2.Server.Plugin.%s.event_id" % test_obj.__name__) + @patch("Bcfg2.Server.Plugin.%s.event_path" % test_obj.__name__) + @patch("Bcfg2.Server.Plugin.%s.AddDirectoryMonitor" % test_obj.__name__) + def test_add_entry(self, mock_Add, mock_event_path, mock_event_id, + mock_isfile, mock_isdir): + gs = self.get_obj() + gs.es_cls = Mock() + gs.es_child_cls = Mock() + + def reset(): + gs.es_cls.reset_mock() + gs.es_child_cls.reset_mock() + mock_Add.reset_mock() + mock_event_path.reset_mock() + mock_event_id.reset_mock() + mock_isfile.reset_mock() + mock_isdir.reset_mock() + + # directory + event = Mock() + event.filename = "foo" + basedir = "test" + epath = os.path.join(gs.data, basedir, event.filename) + ident = os.path.join(basedir, event.filename) + mock_event_path.return_value = epath + mock_event_id.return_value = ident + mock_isdir.return_value = True + mock_isfile.return_value = False + gs.add_entry(event) + mock_Add.assert_called_with(os.path.join("/" + basedir, event.filename)) + self.assertNotIn(ident, gs.entries) + mock_isdir.assert_called_with(epath) + + # file that is not in self.entries + reset() + event = Mock() + event.filename = "foo" + basedir = "test/foo/" + epath = os.path.join(gs.data, basedir, event.filename) + ident = basedir[:-1] + mock_event_path.return_value = epath + mock_event_id.return_value = ident + mock_isdir.return_value = False + mock_isfile.return_value = True + gs.add_entry(event) + self.assertFalse(mock_Add.called) + gs.es_cls.assert_called_with(gs.filename_pattern, + gs.data + ident, + gs.es_child_cls, + gs.encoding) + self.assertIn(ident, gs.entries) + self.assertEqual(gs.entries[ident], gs.es_cls.return_value) + self.assertIn(ident, gs.Entries[gs.entry_type]) + self.assertEqual(gs.Entries[gs.entry_type][ident], + gs.es_cls.return_value.bind_entry) + gs.entries[ident].handle_event.assert_called_with(event) + mock_isfile.assert_called_with(epath) + + # file that is in self.entries + reset() + gs.add_entry(event) + self.assertFalse(mock_Add.called) + self.assertFalse(gs.es_cls.called) + gs.entries[ident].handle_event.assert_called_with(event) + + def test_event_path(self): + gs = self.get_obj() + gs.handles[1] = "/var/lib/foo/" + gs.handles[2] = "/etc/foo/" + gs.handles[3] = "/usr/share/foo/" + event = Mock() + event.filename = "foo" + for i in range(1, 4): + event.requestID = i + self.assertEqual(gs.event_path(event), + os.path.join(datastore, gs.name, + gs.handles[event.requestID].lstrip('/'), + event.filename)) + + @patch("os.path.isdir") + @patch("Bcfg2.Server.Plugin.%s.event_path" % test_obj.__name__) + def test_event_id(self, mock_event_path, mock_isdir): + gs = self.get_obj() + + def reset(): + mock_event_path.reset_mock() + mock_isdir.reset_mock() + + gs.handles[1] = "/var/lib/foo/" + gs.handles[2] = "/etc/foo/" + gs.handles[3] = "/usr/share/foo/" + event = Mock() + event.filename = "foo" + for i in range(1, 4): + event.requestID = i + reset() + mock_isdir.return_value = True + self.assertEqual(gs.event_id(event), + os.path.join(gs.handles[event.requestID].lstrip('/'), + event.filename)) + mock_isdir.assert_called_with(mock_event_path.return_value) + + reset() + mock_isdir.return_value = False + self.assertEqual(gs.event_id(event), + gs.handles[event.requestID].rstrip('/')) + mock_isdir.assert_called_with(mock_event_path.return_value) + + def test_toggle_debug(self): + gs = self.get_obj() + gs.entries = {"/foo": Mock(), + "/bar": Mock(), + "/baz/quux": Mock()} + with patch("Bcfg2.Server.Plugin.Plugin.toggle_debug") as mock_debug: + gs.toggle_debug() + mock_debug.assert_called_with(gs) + for entry in gs.entries.values(): + entry.toggle_debug.assert_any_call() + + TestPlugin.test_toggle_debug(self) + + @patch("Bcfg2.Server.Plugin.%s.event_id" % test_obj.__name__) + @patch("Bcfg2.Server.Plugin.%s.add_entry" % test_obj.__name__) + def test_HandleEvent(self, mock_add_entry, mock_event_id): + gs = self.get_obj() + gs.entries = {"/foo": Mock(), + "/bar": Mock(), + "/baz": Mock(), + "/baz/quux": Mock()} + for path in gs.entries.keys(): + gs.Entries[gs.entry_type] = {path: Mock()} + gs.handles = {1: "/foo/", + 2: "/bar/", + 3: "/baz/", + 4: "/baz/quux"} + + def reset(): + mock_add_entry.reset_mock() + mock_event_id.reset_mock() + for entry in gs.entries.values(): + entry.reset_mock() + + # test event creation, changing entry that doesn't exist + for evt in ["exists", "created", "changed"]: + reset() + event = Mock() + event.filename = "foo" + event.code2str.return_value = evt + gs.HandleEvent(event) + mock_event_id.assert_called_with(event) + mock_add_entry.assert_called_with(event) + + # test deleting entry, changing entry that does exist + for evt in ["changed", "deleted"]: + reset() + event = Mock() + event.filename = "quux" + event.requestID = 4 + event.code2str.return_value = evt + mock_event_id.return_value = "/baz/quux" + gs.HandleEvent(event) + mock_event_id.assert_called_with(event) + self.assertIn(mock_event_id.return_value, gs.entries) + gs.entries[mock_event_id.return_value].handle_event.assert_called_with(event) + self.assertFalse(mock_add_entry.called) + + # test deleting directory + reset() + event = Mock() + event.filename = "quux" + event.requestID = 3 + event.code2str.return_value = "deleted" + mock_event_id.return_value = "/baz/quux" + gs.HandleEvent(event) + mock_event_id.assert_called_with(event) + self.assertNotIn("/baz/quux", gs.entries) + self.assertNotIn("/baz/quux", gs.Entries[gs.entry_type]) + + + -- cgit v1.2.3-1-g7c22 From e911b57eb38dfa0fc06d19e70e02e121ae721e57 Mon Sep 17 00:00:00 2001 From: "Chris St. Pierre" Date: Wed, 15 Aug 2012 08:21:19 -0400 Subject: print function fixes --- testsuite/Testlib/TestOptions.py | 1 - 1 file changed, 1 deletion(-) (limited to 'testsuite') diff --git a/testsuite/Testlib/TestOptions.py b/testsuite/Testlib/TestOptions.py index 4c87b2f42..e3bba787d 100644 --- a/testsuite/Testlib/TestOptions.py +++ b/testsuite/Testlib/TestOptions.py @@ -30,7 +30,6 @@ class TestOption(Bcfg2TestCase): c.get('foo', False, cmd='-f') mock_cp.assert_any_call() mock_open.assert_any_call(Bcfg2.Options.DEFAULT_CONFIG_LOCATION) - print(mock_cp.return_value.get.called) self.assertTrue(mock_cp.return_value.get.called) @patch('Bcfg2.Options.DefaultConfigParser') -- cgit v1.2.3-1-g7c22