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

9 files changed, 150 insertions, 222 deletions

diff --git a/testsuite/Testsrc/Testlib/TestEncryption.py b/testsuite/Testsrc/Testlib/TestEncryption.py
index c03aa66e1..f8fcaa98d 100644
--- a/testsuite/Testsrc/Testlib/TestEncryption.py
+++ b/testsuite/Testsrc/Testlib/TestEncryption.py
@@ -110,37 +110,17 @@ baz
             self.assertRaises(EVPError, ssl_decrypt,
                               crypted, passwd)  # bogus algorithm
 
-        def test_get_algorithm(self):
-            setup = Mock()
-            # we don't care what the default is, as long as there is
-            # one
-            setup.cfp.get.return_value = ALGORITHM
-            self.assertRegexpMatches(get_algorithm(setup),
-                                     r'^[a-z0-9]+_[a-z0-9_]+$')
-            setup.cfp.get.assert_called_with(CFG_SECTION, CFG_ALGORITHM,
-                                             default=ALGORITHM)
-
-            setup.cfp.get.return_value = self.algo
-            self.assertEqual(get_algorithm(setup), self.algo)
-            setup.cfp.get.assert_called_with(CFG_SECTION, CFG_ALGORITHM,
-                                             default=ALGORITHM)
-
-            # test that get_algorithm converts algorithms given in
-            # OpenSSL style to M2Crypto style
-            setup.cfp.get.return_value = "DES-EDE3-CFB8"
-            self.assertEqual(get_algorithm(setup), "des_ede3_cfb8")
-            setup.cfp.get.assert_called_with(CFG_SECTION, CFG_ALGORITHM,
-                                             default=ALGORITHM)
-
-        def test_get_passphrases(self):
+        @patch("Bcfg2.Options.get_option_parser")
+        def test_get_passphrases(self, mock_get_option_parser):
             setup = Mock()
             setup.cfp.has_section.return_value = False
-            self.assertEqual(get_passphrases(setup), dict())
+            mock_get_option_parser.return_value = setup
+            self.assertEqual(get_passphrases(), dict())
 
             setup.cfp.has_section.return_value = True
             setup.cfp.options.return_value = ["foo", "bar", CFG_ALGORITHM]
             setup.cfp.get.return_value = "passphrase"
-            self.assertItemsEqual(get_passphrases(setup),
+            self.assertItemsEqual(get_passphrases(),
                                   dict(foo="passphrase",
                                        bar="passphrase"))
 
@@ -148,14 +128,12 @@ baz
         def test_bruteforce_decrypt(self, mock_passphrases):
             passwd = "a simple passphrase"
             crypted = ssl_encrypt(self.plaintext, passwd)
-            setup = Mock()
 
             # test with no passphrases given nor in config
             mock_passphrases.return_value = dict()
             self.assertRaises(EVPError,
-                              bruteforce_decrypt,
-                              crypted, setup=setup)
-            mock_passphrases.assert_called_with(setup)
+                              bruteforce_decrypt, crypted)
+            mock_passphrases.assert_called_with()
 
             # test with good passphrase given in function call
             mock_passphrases.reset_mock()
@@ -179,15 +157,14 @@ baz
                                                  real=passwd,
                                                  bogus2="also bogus")
             self.assertEqual(self.plaintext,
-                             bruteforce_decrypt(crypted, setup=setup))
-            mock_passphrases.assert_called_with(setup)
+                             bruteforce_decrypt(crypted))
+            mock_passphrases.assert_called_with()
 
             # test that passphrases given in function call take
             # precedence over config
             mock_passphrases.reset_mock()
             self.assertRaises(EVPError,
-                              bruteforce_decrypt,
-                              crypted, setup=setup,
+                              bruteforce_decrypt, crypted,
                               passphrases=["bogus", "also bogus"])
             self.assertFalse(mock_passphrases.called)
 
@@ -195,5 +172,4 @@ baz
             mock_passphrases.reset_mock()
             crypted = ssl_encrypt(self.plaintext, passwd, algorithm=self.algo)
             self.assertEqual(self.plaintext,
-                             bruteforce_decrypt(crypted, setup=setup,
-                                                algorithm=self.algo))
+                             bruteforce_decrypt(crypted, algorithm=self.algo))
diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugin/Testhelpers.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugin/Testhelpers.py
index 6dbdc7667..75cc41a34 100644
--- a/testsuite/Testsrc/Testlib/TestServer/TestPlugin/Testhelpers.py
+++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugin/Testhelpers.py
@@ -1716,16 +1716,17 @@ class TestEntrySet(TestDebuggable):
                      "important:     true",
                      "bogus: line"]
             mock_open.return_value.readlines.return_value = idata
+            eset.metadata = default_path_metadata()
             eset.update_metadata(event)
-            expected = DEFAULT_FILE_METADATA.copy()
+            expected = default_path_metadata()
             expected['owner'] = 'owner'
             expected['group'] = 'GROUP'
             expected['mode'] = '0775'
             expected['important'] = 'true'
-            self.assertItemsEqual(eset.metadata,
-                                  expected)
+            self.assertItemsEqual(eset.metadata, expected)
 
-    def test_reset_metadata(self):
+    @patch("Bcfg2.Server.Plugin.helpers.default_path_metadata")
+    def test_reset_metadata(self, mock_default_path_metadata):
         eset = self.get_obj()
 
         # test info.xml
@@ -1740,7 +1741,8 @@ class TestEntrySet(TestDebuggable):
             event.filename = fname
             eset.metadata = Mock()
             eset.reset_metadata(event)
-            self.assertItemsEqual(eset.metadata, DEFAULT_FILE_METADATA)
+            self.assertEqual(eset.metadata,
+                             mock_default_path_metadata.return_value)
 
     @patch("Bcfg2.Server.Plugin.helpers.bind_info")
     def test_bind_info_to_entry(self, mock_bind_info):
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()
diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestProperties.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestProperties.py
index d66780a20..b0ca77a78 100644
--- a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestProperties.py
+++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestProperties.py
@@ -41,10 +41,10 @@ class TestPropertyFile(Bcfg2TestCase):
         return self.test_obj(path)
 
     def test_write(self):
-        Bcfg2.Server.Plugins.Properties.SETUP = MagicMock()
         pf = self.get_obj()
         pf.validate_data = Mock()
         pf._write = Mock()
+        pf.setup = Mock()
 
         xstr = u("<Properties/>\n")
         pf.xdata = lxml.etree.XML(xstr)
@@ -52,20 +52,20 @@ class TestPropertyFile(Bcfg2TestCase):
         def reset():
             pf.validate_data.reset_mock()
             pf._write.reset_mock()
-            Bcfg2.Server.Plugins.Properties.SETUP.reset_mock()
+            pf.setup.reset_mock()
 
         # test writes disabled
-        Bcfg2.Server.Plugins.Properties.SETUP.cfp.getboolean.return_value = False
+        pf.setup.cfp.getboolean.return_value = False
         self.assertRaises(PluginExecutionError, pf.write)
         self.assertFalse(pf.validate_data.called)
         self.assertFalse(pf._write.called)
-        Bcfg2.Server.Plugins.Properties.SETUP.cfp.getboolean.assert_called_with("properties",
+        pf.setup.cfp.getboolean.assert_called_with("properties",
                                                 "writes_enabled",
                                                 default=True)
 
         # test successful write
         reset()
-        Bcfg2.Server.Plugins.Properties.SETUP.cfp.getboolean.return_value = True
+        pf.setup.cfp.getboolean.return_value = True
         self.assertEqual(pf.write(), pf._write.return_value)
         pf.validate_data.assert_called_with()
         pf._write.assert_called_with()
@@ -301,17 +301,13 @@ class TestXMLPropertyFile(TestPropertyFile, 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):
         pf = self.get_obj()
-        Bcfg2.Server.Plugins.Properties.SETUP = MagicMock()
 
         def reset():
             mock_bruteforce.reset_mock()
-            mock_get_algorithm.reset_mock()
             mock_get_passphrases.reset_mock()
             mock_ssl.reset_mock()
 
@@ -325,29 +321,19 @@ class TestXMLPropertyFile(TestPropertyFile, 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(pf._decrypt(el), mock_ssl.return_value)
-        mock_get_passphrases.assert_called_with(
-            Bcfg2.Server.Plugins.Properties.SETUP)
-        mock_get_algorithm.assert_called_with(
-            Bcfg2.Server.Plugins.Properties.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, pf._decrypt, el)
-        mock_get_passphrases.assert_called_with(
-            Bcfg2.Server.Plugins.Properties.SETUP)
-        mock_get_algorithm.assert_called_with(
-            Bcfg2.Server.Plugins.Properties.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
@@ -355,77 +341,73 @@ class TestXMLPropertyFile(TestPropertyFile, TestStructFile):
         el.set("encrypted", "true")
         mock_bruteforce.return_value = "decrypted with bruteforce"
         self.assertEqual(pf._decrypt(el), mock_bruteforce.return_value)
-        mock_get_passphrases.assert_called_with(
-            Bcfg2.Server.Plugins.Properties.SETUP)
-        mock_get_algorithm.assert_called_with(
-            Bcfg2.Server.Plugins.Properties.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, pf._decrypt, el)
-        mock_get_passphrases.assert_called_with(
-            Bcfg2.Server.Plugins.Properties.SETUP)
-        mock_get_algorithm.assert_called_with(
-            Bcfg2.Server.Plugins.Properties.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)
 
     @patch("copy.copy")
     def test_get_additional_data(self, mock_copy):
-        Bcfg2.Server.Plugins.Properties.SETUP = Mock()
         pf = self.get_obj()
+        pf.setup = Mock()
         pf.XMLMatch = Mock()
         metadata = Mock()
 
         def reset():
             mock_copy.reset_mock()
             pf.XMLMatch.reset_mock()
-            Bcfg2.Server.Plugins.Properties.SETUP.reset_mock()
+            pf.setup.reset_mock()
 
         pf.xdata = lxml.etree.Element("Properties", automatch="true")
         for automatch in [True, False]:
             reset()
-            Bcfg2.Server.Plugins.Properties.SETUP.cfp.getboolean.return_value = automatch
+            pf.setup.cfp.getboolean.return_value = automatch
             self.assertEqual(pf.get_additional_data(metadata),
                              pf.XMLMatch.return_value)
             pf.XMLMatch.assert_called_with(metadata)
-            Bcfg2.Server.Plugins.Properties.SETUP.cfp.getboolean.assert_called_with("properties", "automatch", default=False)
+            pf.setup.cfp.getboolean.assert_called_with("properties",
+                                                       "automatch",
+                                                       default=False)
             self.assertFalse(mock_copy.called)
 
         pf.xdata = lxml.etree.Element("Properties", automatch="false")
         for automatch in [True, False]:
             reset()
-            Bcfg2.Server.Plugins.Properties.SETUP.cfp.getboolean.return_value = automatch
+            pf.setup.cfp.getboolean.return_value = automatch
             self.assertEqual(pf.get_additional_data(metadata),
                              mock_copy.return_value)
             mock_copy.assert_called_with(pf)
             self.assertFalse(pf.XMLMatch.called)
-            Bcfg2.Server.Plugins.Properties.SETUP.cfp.getboolean.assert_called_with("properties", "automatch", default=False)
+            pf.setup.cfp.getboolean.assert_called_with("properties",
+                                                       "automatch",
+                                                       default=False)
 
         pf.xdata = lxml.etree.Element("Properties")
         reset()
-        Bcfg2.Server.Plugins.Properties.SETUP.cfp.getboolean.return_value = False
+        pf.setup.cfp.getboolean.return_value = False
         self.assertEqual(pf.get_additional_data(metadata),
                          mock_copy.return_value)
         mock_copy.assert_called_with(pf)
         self.assertFalse(pf.XMLMatch.called)
-        Bcfg2.Server.Plugins.Properties.SETUP.cfp.getboolean.assert_called_with("properties", "automatch", default=False)
+        pf.setup.cfp.getboolean.assert_called_with("properties",
+                                                   "automatch",
+                                                   default=False)
 
         reset()
-        Bcfg2.Server.Plugins.Properties.SETUP.cfp.getboolean.return_value = True
+        pf.setup.cfp.getboolean.return_value = True
         self.assertEqual(pf.get_additional_data(metadata),
                          pf.XMLMatch.return_value)
         pf.XMLMatch.assert_called_with(metadata)
-        Bcfg2.Server.Plugins.Properties.SETUP.cfp.getboolean.assert_called_with("properties", "automatch", default=False)
+        pf.setup.cfp.getboolean.assert_called_with("properties",
+                                                   "automatch",
+                                                   default=False)
         self.assertFalse(mock_copy.called)
 
 
@@ -449,7 +431,6 @@ class TestProperties(TestPlugin, TestConnector):
         core = Mock()
         p = self.get_obj(core=core)
         self.assertIsInstance(p.store, PropDirectoryBacked)
-        self.assertEqual(Bcfg2.Server.Plugins.Properties.SETUP, core.setup)
 
     @patch("copy.copy")
     def test_get_additional_data(self, mock_copy):