added module-level OptionParser to avoid passing it as an argument or global all over

6 files changed, 99 insertions, 130 deletions

diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgAuthorizedKeysGenerator.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgAuthorizedKeysGenerator.py
index d655a20cd..b77d52033 100644
--- a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgAuthorizedKeysGenerator.py
+++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgAuthorizedKeysGenerator.py
@@ -42,27 +42,25 @@ class TestCfgAuthorizedKeysGenerator(TestCfgGenerator, TestStructFile):
 
     def test_category(self):
         akg = self.get_obj()
-        cfp = Mock()
-        cfp.has_section.return_value = False
-        cfp.has_option.return_value = False
-        Bcfg2.Server.Plugins.Cfg.CfgAuthorizedKeysGenerator.SETUP = Mock()
-        Bcfg2.Server.Plugins.Cfg.CfgAuthorizedKeysGenerator.SETUP.cfp = cfp
+        akg.setup = Mock()
+        akg.setup.cfp.has_section.return_value = False
+        akg.setup.cfp.has_option.return_value = False
 
         self.assertIsNone(akg.category)
-        cfp.has_section.assert_called_with("sshkeys")
+        akg.setup.cfp.has_section.assert_called_with("sshkeys")
 
-        cfp.reset_mock()
-        cfp.has_section.return_value = True
+        akg.setup.reset_mock()
+        akg.setup.cfp.has_section.return_value = True
         self.assertIsNone(akg.category)
-        cfp.has_section.assert_called_with("sshkeys")
-        cfp.has_option.assert_called_with("sshkeys", "category")
-
-        cfp.reset_mock()
-        cfp.has_option.return_value = True
-        self.assertEqual(akg.category, cfp.get.return_value)
-        cfp.has_section.assert_called_with("sshkeys")
-        cfp.has_option.assert_called_with("sshkeys", "category")
-        cfp.get.assert_called_with("sshkeys", "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")
diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgCheetahGenerator.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgCheetahGenerator.py
index fc5d5e53d..31227329c 100644
--- a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgCheetahGenerator.py
+++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgCheetahGenerator.py
@@ -31,11 +31,11 @@ if HAS_CHEETAH or can_skip:
             ccg.data = "data"
             entry = lxml.etree.Element("Path", name="/test.txt")
             metadata = Mock()
-            Bcfg2.Server.Plugins.Cfg.CfgCheetahGenerator.SETUP = MagicMock()
+            ccg.setup = MagicMock()
 
             self.assertEqual(ccg.get_data(entry, metadata),
                              mock_Template.return_value.respond.return_value)
-            Bcfg2.Server.Plugins.Cfg.CfgCheetahGenerator.SETUP.__getitem__.assert_called_with("repo")
+            ccg.setup.__getitem__.assert_called_with("repo")
             mock_Template.assert_called_with("data".decode(ccg.encoding),
                                              compilerSettings=ccg.settings)
             tmpl = mock_Template.return_value
@@ -44,5 +44,4 @@ if HAS_CHEETAH or can_skip:
             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,
-                             Bcfg2.Server.Plugins.Cfg.CfgCheetahGenerator.SETUP.__getitem__.return_value)
+            self.assertEqual(tmpl.repo, ccg.setup.__getitem__.return_value)
diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgEncryptedGenerator.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgEncryptedGenerator.py
index 71a7410da..f8e9b1990 100644
--- a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgEncryptedGenerator.py
+++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgEncryptedGenerator.py
@@ -27,15 +27,12 @@ if can_skip or HAS_CRYPTO:
             pass
 
         @patchIf(HAS_CRYPTO,
-                 "Bcfg2.Server.Plugins.Cfg.CfgEncryptedGenerator.get_algorithm")
-        @patchIf(HAS_CRYPTO,
                  "Bcfg2.Server.Plugins.Cfg.CfgEncryptedGenerator.bruteforce_decrypt")
-        def test_handle_event(self, mock_decrypt, mock_get_algorithm):
+        def test_handle_event(self, mock_decrypt):
             @patch("Bcfg2.Server.Plugins.Cfg.CfgGenerator.handle_event")
             def inner(mock_handle_event):
                 def reset():
                     mock_decrypt.reset_mock()
-                    mock_get_algorithm.reset_mock()
                     mock_handle_event.reset_mock()
 
                 def get_event_data(obj, event):
@@ -47,9 +44,7 @@ if can_skip or HAS_CRYPTO:
                 ceg = self.get_obj()
                 ceg.handle_event(event)
                 mock_handle_event.assert_called_with(ceg, event)
-                mock_decrypt.assert_called_with("encrypted",
-                                                setup=SETUP,
-                                                algorithm=mock_get_algorithm.return_value)
+                mock_decrypt.assert_called_with("encrypted")
                 self.assertEqual(ceg.data, "plaintext")
 
                 reset()
diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgGenshiGenerator.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgGenshiGenerator.py
index 385f8df77..88f3cf3f7 100644
--- a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgGenshiGenerator.py
+++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgGenshiGenerator.py
@@ -43,6 +43,7 @@ if can_skip or HAS_GENSHI:
         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
@@ -51,24 +52,23 @@ if can_skip or HAS_GENSHI:
             entry = lxml.etree.Element("Path", name="/test.txt")
             metadata = Mock()
 
-            Bcfg2.Server.Plugins.Cfg.CfgGenshiGenerator.SETUP = MagicMock()
 
             def reset():
                 cgg.template.reset_mock()
                 cgg._handle_genshi_exception.reset_mock()
-                Bcfg2.Server.Plugins.Cfg.CfgGenshiGenerator.SETUP.reset_mock()
+                cgg.setup.reset_mock()
 
             template_vars = dict(
                 name=entry.get("name"),
                 metadata=metadata,
                 path=cgg.name,
                 source_path=cgg.name,
-                repo=Bcfg2.Server.Plugins.Cfg.CfgGenshiGenerator.SETUP.__getitem__.return_value)
+                repo=cgg.setup.__getitem__.return_value)
 
             self.assertEqual(cgg.get_data(entry, metadata),
                              stream.render.return_value)
             cgg.template.generate.assert_called_with(**template_vars)
-            Bcfg2.Server.Plugins.Cfg.CfgGenshiGenerator.SETUP.__getitem__.assert_called_with("repo")
+            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)
@@ -81,7 +81,7 @@ if can_skip or HAS_GENSHI:
             self.assertEqual(cgg.get_data(entry, metadata),
                              stream.render.return_value)
             cgg.template.generate.assert_called_with(**template_vars)
-            Bcfg2.Server.Plugins.Cfg.CfgGenshiGenerator.SETUP.__getitem__.assert_called_with("repo")
+            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,
@@ -93,7 +93,7 @@ if can_skip or HAS_GENSHI:
             self.assertRaises(UndefinedError,
                               cgg.get_data, entry, metadata)
             cgg.template.generate.assert_called_with(**template_vars)
-            Bcfg2.Server.Plugins.Cfg.CfgGenshiGenerator.SETUP.__getitem__.assert_called_with("repo")
+            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)
@@ -104,7 +104,7 @@ if can_skip or HAS_GENSHI:
             self.assertRaises(ValueError,
                               cgg.get_data, entry, metadata)
             cgg.template.generate.assert_called_with(**template_vars)
-            Bcfg2.Server.Plugins.Cfg.CfgGenshiGenerator.SETUP.__getitem__.assert_called_with("repo")
+            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)
diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgPrivateKeyCreator.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgPrivateKeyCreator.py
index dc4b11241..4c8ab8b43 100644
--- a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgPrivateKeyCreator.py
+++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgPrivateKeyCreator.py
@@ -44,56 +44,56 @@ class TestCfgPrivateKeyCreator(TestCfgCreator, TestStructFile):
 
     def test_category(self):
         pkc = self.get_obj()
-        cfp = Mock()
-        cfp.has_section.return_value = False
-        cfp.has_option.return_value = False
-        Bcfg2.Server.Plugins.Cfg.CfgPrivateKeyCreator.SETUP = Mock()
-        Bcfg2.Server.Plugins.Cfg.CfgPrivateKeyCreator.SETUP.cfp = cfp
+        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)
-        cfp.has_section.assert_called_with("sshkeys")
+        pkc.setup.cfp.has_section.assert_called_with("sshkeys")
 
-        cfp.reset_mock()
-        cfp.has_section.return_value = True
+        pkc.setup.reset_mock()
+        pkc.setup.cfp.has_section.return_value = True
         self.assertIsNone(pkc.category)
-        cfp.has_section.assert_called_with("sshkeys")
-        cfp.has_option.assert_called_with("sshkeys", "category")
+        pkc.setup.cfp.has_section.assert_called_with("sshkeys")
+        pkc.setup.cfp.has_option.assert_called_with("sshkeys", "category")
 
-        cfp.reset_mock()
-        cfp.has_option.return_value = True
-        self.assertEqual(pkc.category, cfp.get.return_value)
-        cfp.has_section.assert_called_with("sshkeys")
-        cfp.has_option.assert_called_with("sshkeys", "category")
-        cfp.get.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.Encryption.get_passphrases")
     def test_passphrase(self, mock_get_passphrases):
         pkc = self.get_obj()
-        cfp = Mock()
-        cfp.has_section.return_value = False
-        cfp.has_option.return_value = False
-        Bcfg2.Server.Plugins.Cfg.CfgPrivateKeyCreator.SETUP = Mock()
-        Bcfg2.Server.Plugins.Cfg.CfgPrivateKeyCreator.SETUP.cfp = cfp
+        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)
-        cfp.has_section.assert_called_with("sshkeys")
+        pkc.setup.cfp.has_section.assert_called_with("sshkeys")
 
-        cfp.reset_mock()
-        cfp.has_section.return_value = True
+        pkc.setup.reset_mock()
+        pkc.setup.cfp.has_section.return_value = True
         self.assertIsNone(pkc.passphrase)
-        cfp.has_section.assert_called_with("sshkeys")
-        cfp.has_option.assert_called_with("sshkeys", "passphrase")
+        pkc.setup.cfp.has_section.assert_called_with("sshkeys")
+        pkc.setup.cfp.has_option.assert_called_with("sshkeys",
+                                                    "passphrase")
 
-        cfp.reset_mock()
-        cfp.get.return_value = "test"
+        pkc.setup.reset_mock()
+        pkc.setup.cfp.get.return_value = "test"
         mock_get_passphrases.return_value = dict(test="foo", test2="bar")
-        cfp.has_option.return_value = True
+        pkc.setup.cfp.has_option.return_value = True
         self.assertEqual(pkc.passphrase, "foo")
-        cfp.has_section.assert_called_with("sshkeys")
-        cfp.has_option.assert_called_with("sshkeys", "passphrase")
-        cfp.get.assert_called_with("sshkeys", "passphrase")
-        mock_get_passphrases.assert_called_with(Bcfg2.Server.Plugins.Cfg.CfgPrivateKeyCreator.SETUP)
+        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")
@@ -282,8 +282,7 @@ class TestCfgPrivateKeyCreator(TestCfgCreator, TestStructFile):
         if HAS_CRYPTO:
             @patch(passphrase, "foo")
             @patch("Bcfg2.Encryption.ssl_encrypt")
-            @patch("Bcfg2.Encryption.get_algorithm")
-            def inner2(mock_get_algorithm, mock_ssl_encrypt):
+            def inner2(mock_ssl_encrypt):
                 reset()
                 mock_ssl_encrypt.return_value = "encryptedprivatekey"
                 Bcfg2.Server.Plugins.Cfg.CfgPrivateKeyCreator.HAS_CRYPTO = True
@@ -302,9 +301,7 @@ class TestCfgPrivateKeyCreator(TestCfgCreator, TestStructFile):
                     "ssh-rsa publickey pubkey.filename\n", group="foo")
                 pkc.write_data.assert_called_with("encryptedprivatekey",
                                                   group="foo", ext=".crypt")
-                mock_ssl_encrypt.assert_called_with(
-                    "privatekey", "foo",
-                    algorithm=mock_get_algorithm.return_value)
+                mock_ssl_encrypt.assert_called_with("privatekey", "foo")
                 mock_rmtree.assert_called_with(datastore)
 
             inner2()
@@ -317,10 +314,9 @@ class TestCfgPrivateKeyCreator(TestCfgCreator, TestStructFile):
 
     @skipUnless(HAS_CRYPTO, "No crypto libraries found, skipping")
     def test_Index_crypto(self):
-        Bcfg2.Server.Plugins.Cfg.CfgPrivateKeyCreator.SETUP = Mock()
-        Bcfg2.Server.Plugins.Cfg.CfgPrivateKeyCreator.SETUP.cfp.get.return_value = "strict"
-
         pkc = self.get_obj()
+        pkc.setup = Mock()
+        pkc.setup.cfp.get.return_value = "strict"
         pkc._decrypt = Mock()
         pkc._decrypt.return_value = 'plaintext'
         pkc.data = '''
@@ -348,7 +344,7 @@ class TestCfgPrivateKeyCreator(TestCfgCreator, TestStructFile):
         self.assertRaises(PluginExecutionError, pkc.Index)
 
         # test failed decryption, lax
-        Bcfg2.Server.Plugins.Cfg.CfgPrivateKeyCreator.SETUP.cfp.get.return_value = "lax"
+        pkc.setup.cfp.get.return_value = "lax"
         pkc._decrypt.reset_mock()
         pkc.Index()
         self.assertItemsEqual(
@@ -358,17 +354,13 @@ class TestCfgPrivateKeyCreator(TestCfgCreator, TestStructFile):
 
     @skipUnless(HAS_CRYPTO, "No crypto libraries found, skipping")
     @patchIf(HAS_CRYPTO, "Bcfg2.Encryption.ssl_decrypt")
-    @patchIf(HAS_CRYPTO, "Bcfg2.Encryption.get_algorithm")
     @patchIf(HAS_CRYPTO, "Bcfg2.Encryption.get_passphrases")
     @patchIf(HAS_CRYPTO, "Bcfg2.Encryption.bruteforce_decrypt")
-    def test_decrypt(self, mock_bruteforce, mock_get_passphrases,
-                     mock_get_algorithm, mock_ssl):
+    def test_decrypt(self, mock_bruteforce, mock_get_passphrases, mock_ssl):
         pkc = self.get_obj()
-        Bcfg2.Server.Plugins.Cfg.CfgPrivateKeyCreator.SETUP = MagicMock()
 
         def reset():
             mock_bruteforce.reset_mock()
-            mock_get_algorithm.reset_mock()
             mock_get_passphrases.reset_mock()
             mock_ssl.reset_mock()
 
@@ -382,29 +374,19 @@ class TestCfgPrivateKeyCreator(TestCfgCreator, TestStructFile):
         reset()
         el = lxml.etree.Element("Test", encrypted="foo")
         el.text = "crypted"
-        mock_get_passphrases.return_value = dict(foo="foopass",
-                                                 bar="barpass")
-        mock_get_algorithm.return_value = "bf_cbc"
+        mock_get_passphrases.return_value = dict(foo="foopass", bar="barpass")
         mock_ssl.return_value = "decrypted with ssl"
         self.assertEqual(pkc._decrypt(el), mock_ssl.return_value)
-        mock_get_passphrases.assert_called_with(
-            Bcfg2.Server.Plugins.Cfg.CfgPrivateKeyCreator.SETUP)
-        mock_get_algorithm.assert_called_with(
-            Bcfg2.Server.Plugins.Cfg.CfgPrivateKeyCreator.SETUP)
-        mock_ssl.assert_called_with(el.text, "foopass",
-                                    algorithm="bf_cbc")
+        mock_get_passphrases.assert_called_with()
+        mock_ssl.assert_called_with(el.text, "foopass")
         self.assertFalse(mock_bruteforce.called)
 
         # test failure to decrypt element with a passphrase in the config
         reset()
         mock_ssl.side_effect = EVPError
         self.assertRaises(EVPError, pkc._decrypt, el)
-        mock_get_passphrases.assert_called_with(
-            Bcfg2.Server.Plugins.Cfg.CfgPrivateKeyCreator.SETUP)
-        mock_get_algorithm.assert_called_with(
-            Bcfg2.Server.Plugins.Cfg.CfgPrivateKeyCreator.SETUP)
-        mock_ssl.assert_called_with(el.text, "foopass",
-                                    algorithm="bf_cbc")
+        mock_get_passphrases.assert_called_with()
+        mock_ssl.assert_called_with(el.text, "foopass")
         self.assertFalse(mock_bruteforce.called)
 
         # test element without valid passphrase
@@ -412,26 +394,14 @@ class TestCfgPrivateKeyCreator(TestCfgCreator, TestStructFile):
         el.set("encrypted", "true")
         mock_bruteforce.return_value = "decrypted with bruteforce"
         self.assertEqual(pkc._decrypt(el), mock_bruteforce.return_value)
-        mock_get_passphrases.assert_called_with(
-            Bcfg2.Server.Plugins.Cfg.CfgPrivateKeyCreator.SETUP)
-        mock_get_algorithm.assert_called_with(
-            Bcfg2.Server.Plugins.Cfg.CfgPrivateKeyCreator.SETUP)
-        mock_bruteforce.assert_called_with(el.text,
-                                           passphrases=["foopass",
-                                                        "barpass"],
-                                           algorithm="bf_cbc")
+        mock_get_passphrases.assert_called_with()
+        mock_bruteforce.assert_called_with(el.text)
         self.assertFalse(mock_ssl.called)
 
         # test failure to decrypt element without valid passphrase
         reset()
         mock_bruteforce.side_effect = EVPError
         self.assertRaises(EVPError, pkc._decrypt, el)
-        mock_get_passphrases.assert_called_with(
-            Bcfg2.Server.Plugins.Cfg.CfgPrivateKeyCreator.SETUP)
-        mock_get_algorithm.assert_called_with(
-            Bcfg2.Server.Plugins.Cfg.CfgPrivateKeyCreator.SETUP)
-        mock_bruteforce.assert_called_with(el.text,
-                                           passphrases=["foopass",
-                                                        "barpass"],
-                                           algorithm="bf_cbc")
+        mock_get_passphrases.assert_called_with()
+        mock_bruteforce.assert_called_with(el.text)
         self.assertFalse(mock_ssl.called)
diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/Test_init.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/Test_init.py
index 2e758774e..ee0b0be9d 100644
--- a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/Test_init.py
+++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/Test_init.py
@@ -439,8 +439,6 @@ class TestCfgEntrySet(TestEntrySet):
     @patch("Bcfg2.Server.Plugins.Cfg.u_str")
     @patch("Bcfg2.Server.Plugins.Cfg.b64encode")
     def test_bind_entry(self, mock_b64encode, mock_u_str):
-        Bcfg2.Server.Plugins.Cfg.SETUP = dict(validate=False)
-
         mock_u_str.side_effect = lambda x: x
 
         eset = self.get_obj()
@@ -448,6 +446,7 @@ class TestCfgEntrySet(TestEntrySet):
         eset._generate_data = Mock()
         eset.get_handlers = Mock()
         eset._validate_data = Mock()
+        eset.setup = dict(validate=False)
 
         def reset():
             mock_b64encode.reset_mock()
@@ -523,7 +522,7 @@ class TestCfgEntrySet(TestEntrySet):
 
         # test successful validation
         entry = reset()
-        Bcfg2.Server.Plugins.Cfg.SETUP['validate'] = True
+        eset.setup['validate'] = 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)
@@ -753,31 +752,39 @@ class TestCfg(TestGroupSpool, TestPullTarget):
     def get_obj(self, core=None):
         if core is None:
             core = Mock()
-        core.setup = MagicMock()
         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):
+    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()
-        core.setup = MagicMock()
         cfg = self.test_obj(core, datastore)
         mock_pulltarget_init.assert_called_with(cfg)
         mock_groupspool_init.assert_called_with(cfg, core, datastore)
-        core.setup.add_option.assert_called_with("validate",
-                                                 Bcfg2.Options.CFG_VALIDATION)
-        core.setup.reparse.assert_called_with()
-
-        core.reset_mock()
-        core.setup.reset_mock()
-        mock_pulltarget_init.reset_mock()
-        mock_groupspool_init.reset_mock()
-        core.setup.__contains__.return_value = True
+        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(core.setup.add_option.called)
-        self.assertFalse(core.setup.reparse.called)
+        self.assertFalse(setup.add_option.called)
+        self.assertFalse(setup.reparse.called)
 
     def test_has_generator(self):
         cfg = self.get_obj()