testsuite: fixed unit tests for server plugins

8 files changed, 112 insertions, 214 deletions

diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgAuthorizedKeysGenerator.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgAuthorizedKeysGenerator.py
index b77d52033..e5cef8fa2 100644
--- a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgAuthorizedKeysGenerator.py
+++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgAuthorizedKeysGenerator.py
@@ -23,6 +23,10 @@ class TestCfgAuthorizedKeysGenerator(TestCfgGenerator, TestStructFile):
     test_obj = CfgAuthorizedKeysGenerator
     should_monitor = False
 
+    def setUp(self):
+        TestCfgGenerator.setUp(self)
+        TestStructFile.setUp(self)
+
     def get_obj(self, name=None, core=None, fam=None):
         if name is None:
             name = self.path
@@ -40,31 +44,9 @@ class TestCfgAuthorizedKeysGenerator(TestCfgGenerator, TestStructFile):
         mock_HandleEvent.assert_called_with(akg, evt)
         mock_handle_event.assert_called_with(akg, evt)
 
-    def test_category(self):
-        akg = self.get_obj()
-        akg.setup = Mock()
-        akg.setup.cfp.has_section.return_value = False
-        akg.setup.cfp.has_option.return_value = False
-
-        self.assertIsNone(akg.category)
-        akg.setup.cfp.has_section.assert_called_with("sshkeys")
-
-        akg.setup.reset_mock()
-        akg.setup.cfp.has_section.return_value = True
-        self.assertIsNone(akg.category)
-        akg.setup.cfp.has_section.assert_called_with("sshkeys")
-        akg.setup.cfp.has_option.assert_called_with("sshkeys", "category")
-
-        akg.setup.reset_mock()
-        akg.setup.cfp.has_option.return_value = True
-        self.assertEqual(akg.category, akg.setup.cfp.get.return_value)
-        akg.setup.cfp.has_section.assert_called_with("sshkeys")
-        akg.setup.cfp.has_option.assert_called_with("sshkeys", "category")
-        akg.setup.cfp.get.assert_called_with("sshkeys", "category")
-
     @patch("Bcfg2.Server.Plugins.Cfg.CfgAuthorizedKeysGenerator.ClientMetadata")
-    @patch("Bcfg2.Server.Plugins.Cfg.CfgAuthorizedKeysGenerator.CfgAuthorizedKeysGenerator.category", "category")
     def test_get_data(self, mock_ClientMetadata):
+        Bcfg2.Options.setup.sshkeys_category = "category"
         akg = self.get_obj()
         akg.XMLMatch = Mock()
 
diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgCheetahGenerator.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgCheetahGenerator.py
index 31227329c..e1ffa7272 100644
--- a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgCheetahGenerator.py
+++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgCheetahGenerator.py
@@ -23,25 +23,25 @@ if HAS_CHEETAH or can_skip:
 
         @skipUnless(HAS_CHEETAH, "Cheetah libraries not found, skipping")
         def setUp(self):
-            pass
+            TestCfgGenerator.setUp(self)
+            set_setup_default("repository", datastore)
 
         @patch("Bcfg2.Server.Plugins.Cfg.CfgCheetahGenerator.Template")
         def test_get_data(self, mock_Template):
-            ccg = self.get_obj(encoding='UTF-8')
+            ccg = self.get_obj()
             ccg.data = "data"
             entry = lxml.etree.Element("Path", name="/test.txt")
             metadata = Mock()
-            ccg.setup = MagicMock()
 
             self.assertEqual(ccg.get_data(entry, metadata),
                              mock_Template.return_value.respond.return_value)
-            ccg.setup.__getitem__.assert_called_with("repo")
-            mock_Template.assert_called_with("data".decode(ccg.encoding),
-                                             compilerSettings=ccg.settings)
+            mock_Template.assert_called_with(
+                "data".decode(Bcfg2.Options.setup.encoding),
+                compilerSettings=ccg.settings)
             tmpl = mock_Template.return_value
             tmpl.respond.assert_called_with()
             self.assertEqual(tmpl.metadata, metadata)
             self.assertEqual(tmpl.name, entry.get("name"))
             self.assertEqual(tmpl.path, entry.get("name"))
             self.assertEqual(tmpl.source_path, ccg.name)
-            self.assertEqual(tmpl.repo, ccg.setup.__getitem__.return_value)
+            self.assertEqual(tmpl.repo, datastore)
diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgEncryptedGenerator.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgEncryptedGenerator.py
index f8e9b1990..5409cf863 100644
--- a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgEncryptedGenerator.py
+++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgEncryptedGenerator.py
@@ -24,7 +24,7 @@ if can_skip or HAS_CRYPTO:
 
         @skipUnless(HAS_CRYPTO, "Encryption libraries not found, skipping")
         def setUp(self):
-            pass
+            TestCfgGenerator.setUp(self)
 
         @patchIf(HAS_CRYPTO,
                  "Bcfg2.Server.Plugins.Cfg.CfgEncryptedGenerator.bruteforce_decrypt")
diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgEncryptedGenshiGenerator.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgEncryptedGenshiGenerator.py
index 330779c99..25d2fb83b 100644
--- a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgEncryptedGenshiGenerator.py
+++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgEncryptedGenshiGenerator.py
@@ -24,4 +24,4 @@ if can_skip or HAS_CRYPTO:
 
         @skipUnless(HAS_CRYPTO, "Encryption libraries not found, skipping")
         def setUp(self):
-            pass
+            TestCfgGenshiGenerator.setUp(self)
diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgGenshiGenerator.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgGenshiGenerator.py
index b73670fb7..9b6e7fe88 100644
--- a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgGenshiGenerator.py
+++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgGenshiGenerator.py
@@ -22,6 +22,10 @@ from TestServer.TestPlugins.TestCfg.Test_init import TestCfgGenerator
 class TestCfgGenshiGenerator(TestCfgGenerator):
     test_obj = CfgGenshiGenerator
 
+    def setUp(self):
+        TestCfgGenerator.setUp(self)
+        set_setup_default("repository", datastore)
+
     def test__init(self):
         TestCfgGenerator.test__init(self)
         cgg = self.get_obj()
@@ -30,7 +34,6 @@ class TestCfgGenshiGenerator(TestCfgGenerator):
     def test_get_data(self):
         cgg = self.get_obj()
         cgg._handle_genshi_exception = Mock()
-        cgg.setup = MagicMock()
         cgg.template = Mock()
         fltr = Mock()
         cgg.template.generate.return_value = fltr
@@ -39,26 +42,25 @@ class TestCfgGenshiGenerator(TestCfgGenerator):
         entry = lxml.etree.Element("Path", name="/test.txt")
         metadata = Mock()
 
-
         def reset():
             cgg.template.reset_mock()
             cgg._handle_genshi_exception.reset_mock()
-            cgg.setup.reset_mock()
 
         template_vars = dict(
             name=entry.get("name"),
             metadata=metadata,
             path=cgg.name,
             source_path=cgg.name,
-            repo=cgg.setup.__getitem__.return_value)
+            repo=datastore)
 
         self.assertEqual(cgg.get_data(entry, metadata),
                          stream.render.return_value)
         cgg.template.generate.assert_called_with(**template_vars)
-        cgg.setup.__getitem__.assert_called_with("repo")
         fltr.filter.assert_called_with(removecomment)
-        stream.render.assert_called_with("text", encoding=cgg.encoding,
-                                         strip_whitespace=False)
+        stream.render.assert_called_with(
+            "text",
+            encoding=Bcfg2.Options.setup.encoding,
+            strip_whitespace=False)
 
         reset()
         def render(fmt, **kwargs):
@@ -68,21 +70,22 @@ class TestCfgGenshiGenerator(TestCfgGenerator):
         self.assertEqual(cgg.get_data(entry, metadata),
                          stream.render.return_value)
         cgg.template.generate.assert_called_with(**template_vars)
-        cgg.setup.__getitem__.assert_called_with("repo")
         fltr.filter.assert_called_with(removecomment)
         self.assertEqual(stream.render.call_args_list,
-                         [call("text", encoding=cgg.encoding,
-                              strip_whitespace=False),
-                          call("text", encoding=cgg.encoding)])
+                         [call("text",
+                               encoding=Bcfg2.Options.setup.encoding,
+                               strip_whitespace=False),
+                          call("text",
+                               encoding=Bcfg2.Options.setup.encoding)])
 
         reset()
         stream.render.side_effect = UndefinedError("test")
         self.assertRaises(UndefinedError,
                           cgg.get_data, entry, metadata)
         cgg.template.generate.assert_called_with(**template_vars)
-        cgg.setup.__getitem__.assert_called_with("repo")
         fltr.filter.assert_called_with(removecomment)
-        stream.render.assert_called_with("text", encoding=cgg.encoding,
+        stream.render.assert_called_with("text",
+                                         encoding=Bcfg2.Options.setup.encoding,
                                          strip_whitespace=False)
 
         reset()
@@ -91,9 +94,9 @@ class TestCfgGenshiGenerator(TestCfgGenerator):
         self.assertRaises(ValueError,
                           cgg.get_data, entry, metadata)
         cgg.template.generate.assert_called_with(**template_vars)
-        cgg.setup.__getitem__.assert_called_with("repo")
         fltr.filter.assert_called_with(removecomment)
-        stream.render.assert_called_with("text", encoding=cgg.encoding,
+        stream.render.assert_called_with("text",
+                                         encoding=Bcfg2.Options.setup.encoding,
                                          strip_whitespace=False)
         self.assertTrue(cgg._handle_genshi_exception.called)
 
@@ -102,14 +105,16 @@ class TestCfgGenshiGenerator(TestCfgGenerator):
         cgg.loader = Mock()
         event = Mock()
         cgg.handle_event(event)
-        cgg.loader.load.assert_called_with(cgg.name,
-                                           cls=NewTextTemplate,
-                                           encoding=cgg.encoding)
+        cgg.loader.load.assert_called_with(
+            cgg.name,
+            cls=NewTextTemplate,
+            encoding=Bcfg2.Options.setup.encoding)
 
         cgg.loader.reset_mock()
         cgg.loader.load.side_effect = OSError
         self.assertRaises(PluginExecutionError,
                           cgg.handle_event, event)
-        cgg.loader.load.assert_called_with(cgg.name,
-                                           cls=NewTextTemplate,
-                                           encoding=cgg.encoding)
+        cgg.loader.load.assert_called_with(
+            cgg.name,
+            cls=NewTextTemplate,
+            encoding=Bcfg2.Options.setup.encoding)
diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgInfoXML.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgInfoXML.py
index 7e7cb5e3c..349da2213 100644
--- a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgInfoXML.py
+++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgInfoXML.py
@@ -21,6 +21,10 @@ from TestServer.TestPlugins.TestCfg.Test_init import TestCfgInfo
 class TestCfgInfoXML(TestCfgInfo):
     test_obj = CfgInfoXML
 
+    def setUp(self):
+        TestCfgInfo.setUp(self)
+        set_setup_default("filemonitor", MagicMock())
+
     def test__init(self):
         TestCfgInfo.test__init(self)
         ci = self.get_obj()
diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgPrivateKeyCreator.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgPrivateKeyCreator.py
index 48d5cdbfe..c4961db1c 100644
--- a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgPrivateKeyCreator.py
+++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgPrivateKeyCreator.py
@@ -42,59 +42,6 @@ class TestCfgPrivateKeyCreator(TestCfgCreator, TestStructFile):
         mock_HandleEvent.assert_called_with(pkc, evt)
         mock_handle_event.assert_called_with(pkc, evt)
 
-    def test_category(self):
-        pkc = self.get_obj()
-        pkc.setup = Mock()
-        pkc.setup.cfp = Mock()
-        pkc.setup.cfp.has_section.return_value = False
-        pkc.setup.cfp.has_option.return_value = False
-
-        self.assertIsNone(pkc.category)
-        pkc.setup.cfp.has_section.assert_called_with("sshkeys")
-
-        pkc.setup.reset_mock()
-        pkc.setup.cfp.has_section.return_value = True
-        self.assertIsNone(pkc.category)
-        pkc.setup.cfp.has_section.assert_called_with("sshkeys")
-        pkc.setup.cfp.has_option.assert_called_with("sshkeys", "category")
-
-        pkc.setup.reset_mock()
-        pkc.setup.cfp.has_option.return_value = True
-        self.assertEqual(pkc.category, pkc.setup.cfp.get.return_value)
-        pkc.setup.cfp.has_section.assert_called_with("sshkeys")
-        pkc.setup.cfp.has_option.assert_called_with("sshkeys", "category")
-        pkc.setup.cfp.get.assert_called_with("sshkeys", "category")
-
-    @skipUnless(HAS_CRYPTO, "No crypto libraries found, skipping")
-    @patchIf(HAS_CRYPTO, "Bcfg2.Server.Encryption.get_passphrases")
-    def test_passphrase(self, mock_get_passphrases):
-        pkc = self.get_obj()
-        pkc.setup = Mock()
-        pkc.setup.cfp = Mock()
-        pkc.setup.cfp.has_section.return_value = False
-        pkc.setup.cfp.has_option.return_value = False
-
-        self.assertIsNone(pkc.passphrase)
-        pkc.setup.cfp.has_section.assert_called_with("sshkeys")
-
-        pkc.setup.reset_mock()
-        pkc.setup.cfp.has_section.return_value = True
-        self.assertIsNone(pkc.passphrase)
-        pkc.setup.cfp.has_section.assert_called_with("sshkeys")
-        pkc.setup.cfp.has_option.assert_called_with("sshkeys",
-                                                    "passphrase")
-
-        pkc.setup.reset_mock()
-        pkc.setup.cfp.get.return_value = "test"
-        mock_get_passphrases.return_value = dict(test="foo", test2="bar")
-        pkc.setup.cfp.has_option.return_value = True
-        self.assertEqual(pkc.passphrase, "foo")
-        pkc.setup.cfp.has_section.assert_called_with("sshkeys")
-        pkc.setup.cfp.has_option.assert_called_with("sshkeys",
-                                                    "passphrase")
-        pkc.setup.cfp.get.assert_called_with("sshkeys", "passphrase")
-        mock_get_passphrases.assert_called_with()
-
     @patch("shutil.rmtree")
     @patch("tempfile.mkdtemp")
     def test__gen_keypair(self, mock_mkdtemp, mock_rmtree):
@@ -153,52 +100,46 @@ class TestCfgPrivateKeyCreator(TestCfgCreator, TestStructFile):
             pkc.XMLMatch.reset_mock()
             metadata.group_in_category.reset_mock()
 
-        category = "Bcfg2.Server.Plugins.Cfg.CfgPrivateKeyCreator.CfgPrivateKeyCreator.category"
-        @patch(category, None)
-        def inner():
-            pkc.XMLMatch.return_value = lxml.etree.Element("PrivateKey")
-            self.assertItemsEqual(pkc.get_specificity(metadata),
-                                  dict(host=metadata.hostname))
-        inner()
-
-        @patch(category, "foo")
-        def inner2():
-            pkc.XMLMatch.return_value = lxml.etree.Element("PrivateKey")
-            self.assertItemsEqual(pkc.get_specificity(metadata),
-                                  dict(group=metadata.group_in_category.return_value,
-                                       prio=50))
-            metadata.group_in_category.assert_called_with("foo")
+        Bcfg2.Options.setup.sshkeys_category = None
+        pkc.XMLMatch.return_value = lxml.etree.Element("PrivateKey")
+        self.assertItemsEqual(pkc.get_specificity(metadata),
+                              dict(host=metadata.hostname))
 
-            reset()
-            pkc.XMLMatch.return_value = lxml.etree.Element("PrivateKey",
-                                                           perhost="true")
-            self.assertItemsEqual(pkc.get_specificity(metadata),
-                                  dict(host=metadata.hostname))
+        Bcfg2.Options.setup.sshkeys_category = "foo"
+        pkc.XMLMatch.return_value = lxml.etree.Element("PrivateKey")
+        self.assertItemsEqual(pkc.get_specificity(metadata),
+                              dict(group=metadata.group_in_category.return_value,
+                                   prio=50))
+        metadata.group_in_category.assert_called_with("foo")
 
-            reset()
-            pkc.XMLMatch.return_value = lxml.etree.Element("PrivateKey",
-                                                           category="bar")
-            self.assertItemsEqual(pkc.get_specificity(metadata),
-                                  dict(group=metadata.group_in_category.return_value,
-                                       prio=50))
-            metadata.group_in_category.assert_called_with("bar")
+        reset()
+        pkc.XMLMatch.return_value = lxml.etree.Element("PrivateKey",
+                                                       perhost="true")
+        self.assertItemsEqual(pkc.get_specificity(metadata),
+                              dict(host=metadata.hostname))
 
-            reset()
-            pkc.XMLMatch.return_value = lxml.etree.Element("PrivateKey",
-                                                           prio="10")
-            self.assertItemsEqual(pkc.get_specificity(metadata),
-                                  dict(group=metadata.group_in_category.return_value,
-                                       prio=10))
-            metadata.group_in_category.assert_called_with("foo")
+        reset()
+        pkc.XMLMatch.return_value = lxml.etree.Element("PrivateKey",
+                                                       category="bar")
+        self.assertItemsEqual(pkc.get_specificity(metadata),
+                              dict(group=metadata.group_in_category.return_value,
+                                   prio=50))
+        metadata.group_in_category.assert_called_with("bar")
 
-            reset()
-            pkc.XMLMatch.return_value = lxml.etree.Element("PrivateKey")
-            metadata.group_in_category.return_value = ''
-            self.assertItemsEqual(pkc.get_specificity(metadata),
-                                  dict(host=metadata.hostname))
-            metadata.group_in_category.assert_called_with("foo")
+        reset()
+        pkc.XMLMatch.return_value = lxml.etree.Element("PrivateKey",
+                                                       prio="10")
+        self.assertItemsEqual(pkc.get_specificity(metadata),
+                              dict(group=metadata.group_in_category.return_value,
+                                   prio=10))
+        metadata.group_in_category.assert_called_with("foo")
 
-        inner2()
+        reset()
+        pkc.XMLMatch.return_value = lxml.etree.Element("PrivateKey")
+        metadata.group_in_category.return_value = ''
+        self.assertItemsEqual(pkc.get_specificity(metadata),
+                              dict(host=metadata.hostname))
+        metadata.group_in_category.assert_called_with("foo")
 
     @patch("shutil.rmtree")
     @patch("%s.open" % builtins)
diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/Test_init.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/Test_init.py
index 07a1b120e..72be50299 100644
--- a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/Test_init.py
+++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/Test_init.py
@@ -152,7 +152,7 @@ class TestCfgInfo(TestCfgBaseFileMatcher):
     @patch("Bcfg2.Server.Plugins.Cfg.CfgBaseFileMatcher.__init__")
     def test__init(self, mock__init):
         ci = self.get_obj("test.txt")
-        mock__init.assert_called_with(ci, "test.txt", None, None)
+        mock__init.assert_called_with(ci, "test.txt", None)
 
     def test_bind_info_to_entry(self):
         ci = self.get_obj()
@@ -173,6 +173,10 @@ class TestCfgCreator(TestCfgBaseFileMatcher):
     test_obj = CfgCreator
     path = "/foo/bar/test.txt"
 
+    def setUp(self):
+        TestCfgBaseFileMatcher.setUp(self)
+        set_setup_default("filemonitor", MagicMock())
+
     def get_obj(self, name=None):
         if name is None:
             name = self.path
@@ -269,31 +273,24 @@ class TestCfgDefaultInfo(TestCfgInfo):
 class TestCfgEntrySet(TestEntrySet):
     test_obj = CfgEntrySet
 
+    def setUp(self):
+        TestEntrySet.setUp(self)
+        set_setup_default("cfg_validation", False)
+
     def test__init(self):
         pass
 
-    def test_handlers(self):
-        # this is really really difficult to mock out, so we just get
-        # a list of handlers and make sure that it roughly matches
-        # what's on the filesystem
-        expected = []
-        for submodule in walk_packages(path=Bcfg2.Server.Plugins.Cfg.__path__,
-                                       prefix="Bcfg2.Server.Plugins.Cfg."):
-            expected.append(submodule[1].rsplit('.', 1)[-1])
-        self.assertItemsEqual(expected, [h.__name__ for h in handlers()])
-
-    @patch("Bcfg2.Server.Plugins.Cfg.handlers")
-    def test_handle_event(self, mock_handlers):
+    def test_handle_event(self):
         eset = self.get_obj()
         eset.entry_init = Mock()
-        mock_handlers.return_value = [Mock(), Mock(), Mock()]
-        for hdlr in mock_handlers.return_value:
+        eset._handlers = [Mock(), Mock(), Mock()]
+        for hdlr in eset._handlers:
             hdlr.__name__ = "handler"
         eset.entries = dict()
 
         def reset():
             eset.entry_init.reset_mock()
-            for hdlr in mock_handlers.return_value:
+            for hdlr in eset._handlers:
                 hdlr.reset_mock()
 
         # test that a bogus deleted event is discarded
@@ -303,7 +300,7 @@ class TestCfgEntrySet(TestEntrySet):
         eset.handle_event(evt)
         self.assertFalse(eset.entry_init.called)
         self.assertItemsEqual(eset.entries, dict())
-        for hdlr in mock_handlers.return_value:
+        for hdlr in eset._handlers:
             self.assertFalse(hdlr.handles.called)
             self.assertFalse(hdlr.ignore.called)
 
@@ -314,7 +311,7 @@ class TestCfgEntrySet(TestEntrySet):
             evt.filename = os.path.join(datastore, "test.txt")
 
             # test with no handler that handles
-            for hdlr in mock_handlers.return_value:
+            for hdlr in eset._handlers:
                 hdlr.handles.return_value = False
                 hdlr.ignore.return_value = False
 
@@ -322,16 +319,16 @@ class TestCfgEntrySet(TestEntrySet):
             eset.handle_event(evt)
             self.assertFalse(eset.entry_init.called)
             self.assertItemsEqual(eset.entries, dict())
-            for hdlr in mock_handlers.return_value:
+            for hdlr in eset._handlers:
                 hdlr.handles.assert_called_with(evt, basename=eset.path)
                 hdlr.ignore.assert_called_with(evt, basename=eset.path)
 
             # test with a handler that handles the entry
             reset()
-            mock_handlers.return_value[-1].handles.return_value = True
+            eset._handlers[-1].handles.return_value = True
             eset.handle_event(evt)
-            eset.entry_init.assert_called_with(evt, mock_handlers.return_value[-1])
-            for hdlr in mock_handlers.return_value:
+            eset.entry_init.assert_called_with(evt, eset._handlers[-1])
+            for hdlr in eset._handlers:
                 hdlr.handles.assert_called_with(evt, basename=eset.path)
                 if not hdlr.return_value:
                     hdlr.ignore.assert_called_with(evt, basename=eset.path)
@@ -339,14 +336,14 @@ class TestCfgEntrySet(TestEntrySet):
             # test with a handler that ignores the entry before one
             # that handles it
             reset()
-            mock_handlers.return_value[0].ignore.return_value = True
+            eset._handlers[0].ignore.return_value = True
             eset.handle_event(evt)
             self.assertFalse(eset.entry_init.called)
-            mock_handlers.return_value[0].handles.assert_called_with(evt,
+            eset._handlers[0].handles.assert_called_with(evt,
+                                                         basename=eset.path)
+            eset._handlers[0].ignore.assert_called_with(evt,
                                                         basename=eset.path)
-            mock_handlers.return_value[0].ignore.assert_called_with(evt,
-                                                       basename=eset.path)
-            for hdlr in mock_handlers.return_value[1:]:
+            for hdlr in eset._handlers[1:]:
                 self.assertFalse(hdlr.handles.called)
                 self.assertFalse(hdlr.ignore.called)
 
@@ -358,7 +355,7 @@ class TestCfgEntrySet(TestEntrySet):
         eset.entries[evt.filename] = Mock()
         eset.handle_event(evt)
         self.assertFalse(eset.entry_init.called)
-        for hdlr in mock_handlers.return_value:
+        for hdlr in eset._handlers:
             self.assertFalse(hdlr.handles.called)
             self.assertFalse(hdlr.ignore.called)
         eset.entries[evt.filename].handle_event.assert_called_with(evt)
@@ -368,7 +365,7 @@ class TestCfgEntrySet(TestEntrySet):
         evt.code2str.return_value = "deleted"
         eset.handle_event(evt)
         self.assertFalse(eset.entry_init.called)
-        for hdlr in mock_handlers.return_value:
+        for hdlr in eset._handlers:
             self.assertFalse(hdlr.handles.called)
             self.assertFalse(hdlr.ignore.called)
         self.assertItemsEqual(eset.entries, dict())
@@ -422,6 +419,7 @@ class TestCfgEntrySet(TestEntrySet):
     def test_bind_entry(self, mock_b64encode, mock_u_str):
         mock_u_str.side_effect = lambda x: x
 
+        Bcfg2.Options.setup.cfg_validation = False
         eset = self.get_obj()
         eset.bind_info_to_entry = Mock()
         eset._generate_data = Mock()
@@ -505,7 +503,7 @@ class TestCfgEntrySet(TestEntrySet):
 
         # test successful validation
         entry = reset()
-        eset.setup['validate'] = True
+        Bcfg2.Options.setup.cfg_validation = True
         bound = eset.bind_entry(entry, metadata)
         eset.bind_info_to_entry.assert_called_with(entry, metadata)
         eset._generate_data.assert_called_with(entry, metadata)
@@ -527,16 +525,16 @@ class TestCfgEntrySet(TestEntrySet):
     def test_get_handlers(self):
         eset = self.get_obj()
         eset.entries['test1.txt'] = CfgInfo("test1.txt")
-        eset.entries['test2.txt'] = CfgGenerator("test2.txt", Mock(), None)
+        eset.entries['test2.txt'] = CfgGenerator("test2.txt", Mock())
         eset.entries['test2.txt'].specific.matches.return_value = True
         eset.entries['test3.txt'] = CfgInfo("test3.txt")
-        eset.entries['test4.txt'] = CfgGenerator("test4.txt", Mock(), None)
+        eset.entries['test4.txt'] = CfgGenerator("test4.txt", Mock())
         eset.entries['test4.txt'].specific.matches.return_value = False
-        eset.entries['test5.txt'] = CfgGenerator("test5.txt", Mock(), None)
+        eset.entries['test5.txt'] = CfgGenerator("test5.txt", Mock())
         eset.entries['test5.txt'].specific.matches.return_value = True
-        eset.entries['test6.txt'] = CfgVerifier("test6.txt", Mock(), None)
+        eset.entries['test6.txt'] = CfgVerifier("test6.txt", Mock())
         eset.entries['test6.txt'].specific.matches.return_value = True
-        eset.entries['test7.txt'] = CfgFilter("test7.txt", Mock(), None)
+        eset.entries['test7.txt'] = CfgFilter("test7.txt", Mock())
         eset.entries['test7.txt'].specific.matches.return_value = False
 
         def reset():
@@ -737,38 +735,6 @@ class TestCfg(TestGroupSpool, TestPullTarget):
             core = Mock()
         return TestGroupSpool.get_obj(self, core=core)
 
-    @patch("Bcfg2.Options.get_option_parser")
-    @patch("Bcfg2.Server.Plugin.GroupSpool.__init__")
-    @patch("Bcfg2.Server.Plugin.PullTarget.__init__")
-    def test__init(self, mock_pulltarget_init, mock_groupspool_init,
-                   mock_get_option_parser):
-        setup = MagicMock()
-        setup.__contains__.return_value = False
-        mock_get_option_parser.return_value = setup
-
-        def reset():
-            core.reset_mock()
-            setup.reset_mock()
-            mock_pulltarget_init.reset_mock()
-            mock_groupspool_init.reset_mock()
-
-        core = Mock()
-        cfg = self.test_obj(core, datastore)
-        mock_pulltarget_init.assert_called_with(cfg)
-        mock_groupspool_init.assert_called_with(cfg, core, datastore)
-        setup.add_option.assert_called_with(
-            "validate",
-            Bcfg2.Options.CFG_VALIDATION)
-        mock_get_option_parser.return_value.reparse.assert_called_with()
-
-        reset()
-        setup.__contains__.return_value = True
-        cfg = self.test_obj(core, datastore)
-        mock_pulltarget_init.assert_called_with(cfg)
-        mock_groupspool_init.assert_called_with(cfg, core, datastore)
-        self.assertFalse(setup.add_option.called)
-        self.assertFalse(setup.reparse.called)
-
     def test_has_generator(self):
         cfg = self.get_obj()
         cfg.entries = dict()