converted InfoXML objects from XMLSrc to StructFile

3 files changed, 42 insertions, 135 deletions

diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgInfoXML.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgInfoXML.py
index 839e9c3b8..7e7cb5e3c 100644
--- a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgInfoXML.py
+++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgInfoXML.py
@@ -27,47 +27,16 @@ class TestCfgInfoXML(TestCfgInfo):
         self.assertIsInstance(ci.infoxml, InfoXML)
 
     def test_bind_info_to_entry(self):
-        entry = lxml.etree.Element("Path", name="/test.txt")
-        metadata = Mock()
         ci = self.get_obj()
         ci.infoxml = Mock()
-        ci._set_info = Mock()
-
-        self.assertRaises(PluginExecutionError,
-                          ci.bind_info_to_entry, entry, metadata)
-        ci.infoxml.pnode.Match.assert_called_with(metadata, dict(),
-                                                  entry=entry)
-        self.assertFalse(ci._set_info.called)
-
-        ci.infoxml.reset_mock()
-        ci._set_info.reset_mock()
-        mdata_value = Mock()
-        def set_mdata(metadata, mdata, entry=None):
-            mdata['Info'] = {None: mdata_value}
+        entry = Mock()
+        metadata = Mock()
 
-        ci.infoxml.pnode.Match.side_effect = set_mdata
         ci.bind_info_to_entry(entry, metadata)
-        ci.infoxml.pnode.Match.assert_called_with(metadata,
-                                                  dict(Info={None: mdata_value}),
-                                                  entry=entry)
-        ci._set_info.assert_called_with(entry, mdata_value)
+        ci.infoxml.BindEntry.assert_called_with(entry, metadata)
 
     def test_handle_event(self):
         ci = self.get_obj()
         ci.infoxml = Mock()
         ci.handle_event(Mock)
         ci.infoxml.HandleEvent.assert_called_with()
-
-    def test__set_info(self):
-        @patch("Bcfg2.Server.Plugins.Cfg.CfgInfo._set_info")
-        def inner(mock_set_info):
-            ci = self.get_obj()
-            entry = Mock()
-            info = {"foo": "foo",
-                    "__children__": ["one", "two"]}
-            ci._set_info(entry, info)
-            self.assertItemsEqual(entry.append.call_args_list,
-                                  [call(c) for c in info['__children__']])
-
-        inner()
-        TestCfgInfo.test__set_info(self)
diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/Test_init.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/Test_init.py
index ee0b0be9d..ab383e4f3 100644
--- a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/Test_init.py
+++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/Test_init.py
@@ -159,21 +159,6 @@ class TestCfgInfo(TestCfgBaseFileMatcher):
         self.assertRaises(NotImplementedError,
                           ci.bind_info_to_entry, Mock(), Mock())
 
-    def test__set_info(self):
-        ci = self.get_obj()
-        entry = Mock()
-        entry.attrib = dict()
-
-        info = {"foo": "foo",
-                "_bar": "bar",
-                "bar:baz=quux": "quux",
-                "baz__": "baz",
-                "__quux": "quux"}
-        ci._set_info(entry, info)
-        self.assertItemsEqual(entry.attrib,
-                              dict([(k, v) for k, v in info.items()
-                                    if not k.startswith("__")]))
-
 
 class TestCfgVerifier(TestCfgBaseFileMatcher):
     test_obj = CfgVerifier
@@ -259,29 +244,26 @@ class TestCfgCreator(TestCfgBaseFileMatcher):
 class TestCfgDefaultInfo(TestCfgInfo):
     test_obj = CfgDefaultInfo
 
-    def get_obj(self, defaults=None):
-        if defaults is None:
-            defaults = dict()
-        return self.test_obj(defaults)
+    def get_obj(self, *_):
+        return self.test_obj()
 
-    @patch("Bcfg2.Server.Plugins.Cfg.CfgInfo.__init__")
-    def test__init(self, mock__init):
-        defaults = Mock()
-        cdi = self.get_obj(defaults=defaults)
-        mock__init.assert_called_with(cdi, '')
-        self.assertEqual(defaults, cdi.defaults)
+    def test__init(self):
+        pass
 
     def test_handle_event(self):
         # this CfgInfo handler doesn't handle any events -- it's not
         # file-driven, but based on the built-in defaults
         pass
 
-    def test_bind_info_to_entry(self):
+    @patch("Bcfg2.Server.Plugin.default_path_metadata")
+    def test_bind_info_to_entry(self, mock_default_path_metadata):
         cdi = self.get_obj()
-        cdi._set_info = Mock()
-        entry = Mock()
+        entry = lxml.etree.Element("Test", name="test")
+        mock_default_path_metadata.return_value = \
+            dict(owner="root", mode="0600")
         cdi.bind_info_to_entry(entry, Mock())
-        cdi._set_info.assert_called_with(entry, cdi.defaults)
+        self.assertItemsEqual(entry.attrib,
+                              dict(owner="root", mode="0600", name="test"))
 
 
 class TestCfgEntrySet(TestEntrySet):
@@ -599,24 +581,24 @@ class TestCfgEntrySet(TestEntrySet):
             if entry.specific is not None:
                 self.assertFalse(entry.specific.matches.called)
 
-    def test_bind_info_to_entry(self):
-        default_info = Bcfg2.Server.Plugins.Cfg.DEFAULT_INFO
+    @patch("Bcfg2.Server.Plugins.Cfg.CfgDefaultInfo")
+    def test_bind_info_to_entry(self, mock_DefaultInfo):
         eset = self.get_obj()
         eset.get_handlers = Mock()
         eset.get_handlers.return_value = []
-        Bcfg2.Server.Plugins.Cfg.DEFAULT_INFO = Mock()
         metadata = Mock()
 
         def reset():
             eset.get_handlers.reset_mock()
-            Bcfg2.Server.Plugins.Cfg.DEFAULT_INFO.reset_mock()
+            mock_DefaultInfo.reset_mock()
             return lxml.etree.Element("Path", name="/test.txt")
 
         # test with no info handlers
         entry = reset()
         eset.bind_info_to_entry(entry, metadata)
         eset.get_handlers.assert_called_with(metadata, CfgInfo)
-        Bcfg2.Server.Plugins.Cfg.DEFAULT_INFO.bind_info_to_entry.assert_called_with(entry, metadata)
+        mock_DefaultInfo.return_value.bind_info_to_entry.assert_called_with(
+            entry, metadata)
         self.assertEqual(entry.get("type"), "file")
 
         # test with one info handler
@@ -625,7 +607,8 @@ class TestCfgEntrySet(TestEntrySet):
         eset.get_handlers.return_value = [handler]
         eset.bind_info_to_entry(entry, metadata)
         eset.get_handlers.assert_called_with(metadata, CfgInfo)
-        Bcfg2.Server.Plugins.Cfg.DEFAULT_INFO.bind_info_to_entry.assert_called_with(entry, metadata)
+        mock_DefaultInfo.return_value.bind_info_to_entry.assert_called_with(
+            entry, metadata)
         handler.bind_info_to_entry.assert_called_with(entry, metadata)
         self.assertEqual(entry.get("type"), "file")
 
@@ -635,7 +618,8 @@ class TestCfgEntrySet(TestEntrySet):
         eset.get_handlers.return_value = handlers
         eset.bind_info_to_entry(entry, metadata)
         eset.get_handlers.assert_called_with(metadata, CfgInfo)
-        Bcfg2.Server.Plugins.Cfg.DEFAULT_INFO.bind_info_to_entry.assert_called_with(entry, metadata)
+        mock_DefaultInfo.return_value.bind_info_to_entry.assert_called_with(
+            entry, metadata)
         # we don't care which handler gets called as long as exactly
         # one of them does
         called = 0
@@ -646,8 +630,6 @@ class TestCfgEntrySet(TestEntrySet):
         self.assertEqual(called, 1)
         self.assertEqual(entry.get("type"), "file")
 
-        Bcfg2.Server.Plugins.Cfg.DEFAULT_INFO = default_info
-
     def test_create_data(self):
         eset = self.get_obj()
         eset.best_matching = Mock()
diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestRules.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestRules.py
index f018b45dc..7083fff06 100644
--- a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestRules.py
+++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestRules.py
@@ -45,81 +45,37 @@ class TestRules(TestPrioDir):
         entry = lxml.etree.Element("Package", name="foo")
         self.assertFalse(r.HandlesEntry(entry, metadata))
 
-    def test_BindEntry(self, method="BindEntry"):
-        r = self.get_obj()
-        r.get_attrs = Mock()
-        r.get_attrs.return_value = dict(overwrite="new", add="add",
-                                        text="text")
-        entry = lxml.etree.Element("Test", overwrite="old", keep="keep")
-        metadata = Mock()
-
-        getattr(r, method)(entry, metadata)
-        r.get_attrs.assert_called_with(entry, metadata)
-        self.assertItemsEqual(entry.attrib,
-                              dict(overwrite="old", add="add", keep="keep",
-                                   text="text"))
-
-    def test_HandleEntry(self):
-        self.test_BindEntry(method="HandleEntry")
-
     @patch("Bcfg2.Server.Plugin.PrioDir._matches")
     def test__matches(self, mock_matches):
-        """ test _matches() behavior regardless of state of _regex_enabled """
         r = self.get_obj()
         metadata = Mock()
 
+        # test parent _matches() returning True
         entry = lxml.etree.Element("Path", name="/etc/foo.conf")
-        rules = []
+        candidate = lxml.etree.Element("Path", name="/etc/bar.conf")
         mock_matches.return_value = True
-        self.assertTrue(r._matches(entry, metadata, rules))
-        mock_matches.assert_called_with(r, entry, metadata, rules)
+        self.assertTrue(r._matches(entry, metadata, candidate))
+        mock_matches.assert_called_with(r, entry, metadata, candidate)
 
-        # test special Path cases -- adding and removing trailing slash
+        # test all conditions returning False
         mock_matches.reset_mock()
         mock_matches.return_value = False
-        rules = ["/etc/foo/", "/etc/bar"]
-        entry = lxml.etree.Element("Path", name="/etc/foo")
-        self.assertTrue(r._matches(entry, metadata, rules))
-        mock_matches.assert_called_with(r, entry, metadata, rules)
+        self.assertFalse(r._matches(entry, metadata, candidate))
+        mock_matches.assert_called_with(r, entry, metadata, candidate)
 
+        # test special Path cases -- adding and removing trailing slash
         mock_matches.reset_mock()
-        entry = lxml.etree.Element("Path", name="/etc/bar/")
-        self.assertTrue(r._matches(entry, metadata, rules))
-        mock_matches.assert_called_with(r, entry, metadata, rules)
-
-    @patch("Bcfg2.Server.Plugin.PrioDir._matches")
-    def test__matches_regex_disabled(self, mock_matches):
-        """ test failure to match with regex disabled """
-        r = self.get_obj()
-        self.set_regex_enabled(r, False)
-        metadata = Mock()
-        mock_matches.return_value = False
-
-        entry = lxml.etree.Element("Path", name="/etc/foo.conf")
-        rules = []
-        self.assertFalse(r._matches(entry, metadata, rules))
-        mock_matches.assert_called_with(r, entry, metadata, rules)
-
-    @patch("Bcfg2.Server.Plugin.PrioDir._matches")
-    def test__matches_regex_enabled(self, mock_matches):
-        """ test match with regex enabled """
-        r = self.get_obj()
-        self.set_regex_enabled(r, True)
-        metadata = Mock()
-        mock_matches.return_value = False
-
-        entry = lxml.etree.Element("Path", name="/etc/foo.conf")
-        rules = ["/etc/.*\.conf", "/etc/bar"]
-        self.assertTrue(r._matches(entry, metadata, rules))
-        mock_matches.assert_called_with(r, entry, metadata, rules)
-        self.assertIn("/etc/.*\.conf", r._regex_cache.keys())
-
-    def set_regex_enabled(self, rules_obj, state):
-        """ set the state of regex_enabled for this implementation of
-        Rules """
-        if not isinstance(rules_obj.core.setup, MagicMock):
-            rules_obj.core.setup = MagicMock()
-        rules_obj.core.setup.cfp.getboolean.return_value = state
+        withslash = lxml.etree.Element("Path", name="/etc/foo")
+        withoutslash = lxml.etree.Element("Path", name="/etc/foo/")
+        self.assertTrue(r._matches(withslash, metadata, withoutslash))
+        self.assertTrue(r._matches(withoutslash, metadata, withslash))
+
+        if r._regex_enabled:
+            mock_matches.reset_mock()
+            candidate = lxml.etree.Element("Path", name="/etc/.*\.conf")
+            self.assertTrue(r._matches(entry, metadata, candidate))
+            mock_matches.assert_called_with(r, entry, metadata, candidate)
+            self.assertIn("/etc/.*\.conf", r._regex_cache.keys())
 
     def test__regex_enabled(self):
         r = self.get_obj()