testsuite: removed obsolete can_skip variable

This was needed when we implemented skipping ourselves in a hackish
way; with unittest2, skipping is implemented correctly, so tests can
always be skipped

8 files changed, 369 insertions, 390 deletions

diff --git a/testsuite/Testsrc/Testlib/TestServer/TestEncryption.py b/testsuite/Testsrc/Testlib/TestServer/TestEncryption.py
index 2267e9d6c..cfb0c023b 100644
--- a/testsuite/Testsrc/Testlib/TestServer/TestEncryption.py
+++ b/testsuite/Testsrc/Testlib/TestServer/TestEncryption.py
@@ -22,129 +22,128 @@ except ImportError:
     HAS_CRYPTO = False
 
 
-if can_skip or HAS_CRYPTO:
-    class TestEncryption(Bcfg2TestCase):
-        plaintext = """foo bar
+class TestEncryption(Bcfg2TestCase):
+    plaintext = """foo bar
 baz
 ö
 \t\tquux
 """ + "a" * 16384  # 16K is completely arbitrary
-        iv = "0123456789ABCDEF"
-        salt = "01234567"
-        algo = "des_cbc"
-
-        @skipUnless(HAS_CRYPTO, "Encryption libraries not found")
-        def setUp(self):
-            Bcfg2.Options.setup.algorithm = "aes_256_cbc"
-
-        def test_str_crypt(self):
-            """ test str_encrypt/str_decrypt """
-            key = "a simple key"
-
-            # simple symmetrical test with no options
-            crypted = str_encrypt(self.plaintext, key)
-            self.assertEqual(self.plaintext, str_decrypt(crypted, key))
-
-            # symmetrical test with lots of options
-            crypted = str_encrypt(self.plaintext, key,
-                                  iv=self.iv, salt=self.salt,
-                                  algorithm=self.algo)
-            self.assertEqual(self.plaintext,
-                             str_decrypt(crypted, key, iv=self.iv,
-                                         algorithm=self.algo))
-
-            # test that different algorithms are actually used
-            self.assertNotEqual(str_encrypt(self.plaintext, key),
-                                str_encrypt(self.plaintext, key,
-                                            algorithm=self.algo))
-
-            # test that different keys are actually used
-            self.assertNotEqual(str_encrypt(self.plaintext, key),
-                                str_encrypt(self.plaintext, "different key"))
-
-            # test that different IVs are actually used
-            self.assertNotEqual(str_encrypt(self.plaintext, key, iv=self.iv),
-                                str_encrypt(self.plaintext, key))
-
-            # test that errors are raised on bad decrypts
-            crypted = str_encrypt(self.plaintext, key, algorithm=self.algo)
-            self.assertRaises(EVPError, str_decrypt,
-                              crypted, "bogus key", algorithm=self.algo)
-            self.assertRaises(EVPError, str_decrypt,
-                              crypted, key)  # bogus algorithm
-
-        def test_ssl_crypt(self):
-            """ test ssl_encrypt/ssl_decrypt """
-            passwd = "a simple passphrase"
-
-            # simple symmetrical test
-            crypted = ssl_encrypt(self.plaintext, passwd)
-            self.assertEqual(self.plaintext, ssl_decrypt(crypted, passwd))
-
-            # more complex symmetrical test
-            crypted = ssl_encrypt(self.plaintext, passwd, algorithm=self.algo,
-                                  salt=self.salt)
-            self.assertEqual(self.plaintext,
-                             ssl_decrypt(crypted, passwd, algorithm=self.algo))
-
-            # test that different algorithms are actually used
-            self.assertNotEqual(ssl_encrypt(self.plaintext, passwd),
-                                ssl_encrypt(self.plaintext, passwd,
-                                            algorithm=self.algo))
-
-            # test that different passwords are actually used
-            self.assertNotEqual(ssl_encrypt(self.plaintext, passwd),
-                                ssl_encrypt(self.plaintext, "different pass"))
-
-            # there's no reasonable test we can do to see if the
-            # output is base64-encoded, unfortunately, but if it's
-            # obviously not we fail
-            crypted = ssl_encrypt(self.plaintext, passwd)
-            self.assertRegexpMatches(crypted, r'^[A-Za-z0-9+/]+[=]{0,2}$')
-
-            # test that errors are raised on bad decrypts
-            crypted = ssl_encrypt(self.plaintext, passwd,
-                                  algorithm=self.algo)
-            self.assertRaises(EVPError, ssl_decrypt,
-                              crypted, "bogus passwd", algorithm=self.algo)
-            self.assertRaises(EVPError, ssl_decrypt,
-                              crypted, passwd)  # bogus algorithm
-
-        def test_bruteforce_decrypt(self):
-            passwd = "a simple passphrase"
-            crypted = ssl_encrypt(self.plaintext, passwd)
-
-            # test with no passphrases given nor in config
-            Bcfg2.Options.setup.passphrases = dict()
-            self.assertRaises(EVPError,
-                              bruteforce_decrypt, crypted)
-
-            # test with good passphrase given in function call
-            self.assertEqual(self.plaintext,
-                             bruteforce_decrypt(crypted,
-                                                passphrases=["bogus pass",
-                                                             passwd,
-                                                             "also bogus"]))
-
-            # test with no good passphrase given nor in config
-            self.assertRaises(EVPError,
-                              bruteforce_decrypt,
-                              crypted, passphrases=["bogus", "also bogus"])
-
-            # test with good passphrase in config file
-            Bcfg2.Options.setup.passphrases = dict(bogus="bogus",
-                                                   real=passwd,
-                                                   bogus2="also bogus")
-            self.assertEqual(self.plaintext,
-                             bruteforce_decrypt(crypted))
-
-            # test that passphrases given in function call take
-            # precedence over config
-            self.assertRaises(EVPError,
-                              bruteforce_decrypt, crypted,
-                              passphrases=["bogus", "also bogus"])
-
-            # test that different algorithms are used
-            crypted = ssl_encrypt(self.plaintext, passwd, algorithm=self.algo)
-            self.assertEqual(self.plaintext,
-                             bruteforce_decrypt(crypted, algorithm=self.algo))
+    iv = "0123456789ABCDEF"
+    salt = "01234567"
+    algo = "des_cbc"
+
+    @skipUnless(HAS_CRYPTO, "Encryption libraries not found")
+    def setUp(self):
+        Bcfg2.Options.setup.algorithm = "aes_256_cbc"
+
+    def test_str_crypt(self):
+        """ test str_encrypt/str_decrypt """
+        key = "a simple key"
+
+        # simple symmetrical test with no options
+        crypted = str_encrypt(self.plaintext, key)
+        self.assertEqual(self.plaintext, str_decrypt(crypted, key))
+
+        # symmetrical test with lots of options
+        crypted = str_encrypt(self.plaintext, key,
+                              iv=self.iv, salt=self.salt,
+                              algorithm=self.algo)
+        self.assertEqual(self.plaintext,
+                         str_decrypt(crypted, key, iv=self.iv,
+                                     algorithm=self.algo))
+
+        # test that different algorithms are actually used
+        self.assertNotEqual(str_encrypt(self.plaintext, key),
+                            str_encrypt(self.plaintext, key,
+                                        algorithm=self.algo))
+
+        # test that different keys are actually used
+        self.assertNotEqual(str_encrypt(self.plaintext, key),
+                            str_encrypt(self.plaintext, "different key"))
+
+        # test that different IVs are actually used
+        self.assertNotEqual(str_encrypt(self.plaintext, key, iv=self.iv),
+                            str_encrypt(self.plaintext, key))
+
+        # test that errors are raised on bad decrypts
+        crypted = str_encrypt(self.plaintext, key, algorithm=self.algo)
+        self.assertRaises(EVPError, str_decrypt,
+                          crypted, "bogus key", algorithm=self.algo)
+        self.assertRaises(EVPError, str_decrypt,
+                          crypted, key)  # bogus algorithm
+
+    def test_ssl_crypt(self):
+        """ test ssl_encrypt/ssl_decrypt """
+        passwd = "a simple passphrase"
+
+        # simple symmetrical test
+        crypted = ssl_encrypt(self.plaintext, passwd)
+        self.assertEqual(self.plaintext, ssl_decrypt(crypted, passwd))
+
+        # more complex symmetrical test
+        crypted = ssl_encrypt(self.plaintext, passwd, algorithm=self.algo,
+                              salt=self.salt)
+        self.assertEqual(self.plaintext,
+                         ssl_decrypt(crypted, passwd, algorithm=self.algo))
+
+        # test that different algorithms are actually used
+        self.assertNotEqual(ssl_encrypt(self.plaintext, passwd),
+                            ssl_encrypt(self.plaintext, passwd,
+                                        algorithm=self.algo))
+
+        # test that different passwords are actually used
+        self.assertNotEqual(ssl_encrypt(self.plaintext, passwd),
+                            ssl_encrypt(self.plaintext, "different pass"))
+
+        # there's no reasonable test we can do to see if the
+        # output is base64-encoded, unfortunately, but if it's
+        # obviously not we fail
+        crypted = ssl_encrypt(self.plaintext, passwd)
+        self.assertRegexpMatches(crypted, r'^[A-Za-z0-9+/]+[=]{0,2}$')
+
+        # test that errors are raised on bad decrypts
+        crypted = ssl_encrypt(self.plaintext, passwd,
+                              algorithm=self.algo)
+        self.assertRaises(EVPError, ssl_decrypt,
+                          crypted, "bogus passwd", algorithm=self.algo)
+        self.assertRaises(EVPError, ssl_decrypt,
+                          crypted, passwd)  # bogus algorithm
+
+    def test_bruteforce_decrypt(self):
+        passwd = "a simple passphrase"
+        crypted = ssl_encrypt(self.plaintext, passwd)
+
+        # test with no passphrases given nor in config
+        Bcfg2.Options.setup.passphrases = dict()
+        self.assertRaises(EVPError,
+                          bruteforce_decrypt, crypted)
+
+        # test with good passphrase given in function call
+        self.assertEqual(self.plaintext,
+                         bruteforce_decrypt(crypted,
+                                            passphrases=["bogus pass",
+                                                         passwd,
+                                                         "also bogus"]))
+
+        # test with no good passphrase given nor in config
+        self.assertRaises(EVPError,
+                          bruteforce_decrypt,
+                          crypted, passphrases=["bogus", "also bogus"])
+
+        # test with good passphrase in config file
+        Bcfg2.Options.setup.passphrases = dict(bogus="bogus",
+                                               real=passwd,
+                                               bogus2="also bogus")
+        self.assertEqual(self.plaintext,
+                         bruteforce_decrypt(crypted))
+
+        # test that passphrases given in function call take
+        # precedence over config
+        self.assertRaises(EVPError,
+                          bruteforce_decrypt, crypted,
+                          passphrases=["bogus", "also bogus"])
+
+        # test that different algorithms are used
+        crypted = ssl_encrypt(self.plaintext, passwd, algorithm=self.algo)
+        self.assertEqual(self.plaintext,
+                         bruteforce_decrypt(crypted, algorithm=self.algo))
diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgCheetahGenerator.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgCheetahGenerator.py
index e1ffa7272..2285fb458 100644
--- a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgCheetahGenerator.py
+++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgCheetahGenerator.py
@@ -17,31 +17,30 @@ from common import *
 from TestServer.TestPlugins.TestCfg.Test_init import TestCfgGenerator
 
 
-if HAS_CHEETAH or can_skip:
-    class TestCfgCheetahGenerator(TestCfgGenerator):
-        test_obj = CfgCheetahGenerator
+class TestCfgCheetahGenerator(TestCfgGenerator):
+    test_obj = CfgCheetahGenerator
 
-        @skipUnless(HAS_CHEETAH, "Cheetah libraries not found, skipping")
-        def setUp(self):
-            TestCfgGenerator.setUp(self)
-            set_setup_default("repository", datastore)
+    @skipUnless(HAS_CHEETAH, "Cheetah libraries not found, skipping")
+    def setUp(self):
+        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()
-            ccg.data = "data"
-            entry = lxml.etree.Element("Path", name="/test.txt")
-            metadata = Mock()
+    @patch("Bcfg2.Server.Plugins.Cfg.CfgCheetahGenerator.Template")
+    def test_get_data(self, mock_Template):
+        ccg = self.get_obj()
+        ccg.data = "data"
+        entry = lxml.etree.Element("Path", name="/test.txt")
+        metadata = Mock()
 
-            self.assertEqual(ccg.get_data(entry, metadata),
-                             mock_Template.return_value.respond.return_value)
-            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, datastore)
+        self.assertEqual(ccg.get_data(entry, metadata),
+                         mock_Template.return_value.respond.return_value)
+        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, datastore)
diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgEncryptedCheetahGenerator.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgEncryptedCheetahGenerator.py
index 46062569d..4c987551b 100644
--- a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgEncryptedCheetahGenerator.py
+++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgEncryptedCheetahGenerator.py
@@ -30,18 +30,17 @@ except ImportError:
     HAS_CRYPTO = False
 
 
-if can_skip or (HAS_CRYPTO and HAS_CHEETAH):
-    class TestCfgEncryptedCheetahGenerator(TestCfgCheetahGenerator,
-                                           TestCfgEncryptedGenerator):
-        test_obj = CfgEncryptedCheetahGenerator
+class TestCfgEncryptedCheetahGenerator(TestCfgCheetahGenerator,
+                                       TestCfgEncryptedGenerator):
+    test_obj = CfgEncryptedCheetahGenerator
 
-        @skipUnless(HAS_CRYPTO, "Encryption libraries not found, skipping")
-        @skipUnless(HAS_CHEETAH, "Cheetah libraries not found, skipping")
-        def setUp(self):
-            pass
+    @skipUnless(HAS_CRYPTO, "Encryption libraries not found, skipping")
+    @skipUnless(HAS_CHEETAH, "Cheetah libraries not found, skipping")
+    def setUp(self):
+        pass
 
-        def test_handle_event(self):
-            TestCfgEncryptedGenerator.test_handle_event(self)
+    def test_handle_event(self):
+        TestCfgEncryptedGenerator.test_handle_event(self)
 
-        def test_get_data(self):
-            TestCfgCheetahGenerator.test_get_data(self)
+    def test_get_data(self):
+        TestCfgCheetahGenerator.test_get_data(self)
diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgEncryptedGenerator.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgEncryptedGenerator.py
index 5409cf863..873ebd837 100644
--- a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgEncryptedGenerator.py
+++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgEncryptedGenerator.py
@@ -18,54 +18,53 @@ from common import *
 from TestServer.TestPlugins.TestCfg.Test_init import TestCfgGenerator
 
 
-if can_skip or HAS_CRYPTO:
-    class TestCfgEncryptedGenerator(TestCfgGenerator):
-        test_obj = CfgEncryptedGenerator
+class TestCfgEncryptedGenerator(TestCfgGenerator):
+    test_obj = CfgEncryptedGenerator
 
-        @skipUnless(HAS_CRYPTO, "Encryption libraries not found, skipping")
-        def setUp(self):
-            TestCfgGenerator.setUp(self)
+    @skipUnless(HAS_CRYPTO, "Encryption libraries not found, skipping")
+    def setUp(self):
+        TestCfgGenerator.setUp(self)
 
-        @patchIf(HAS_CRYPTO,
-                 "Bcfg2.Server.Plugins.Cfg.CfgEncryptedGenerator.bruteforce_decrypt")
-        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_handle_event.reset_mock()
+    @patchIf(HAS_CRYPTO,
+             "Bcfg2.Server.Plugins.Cfg.CfgEncryptedGenerator.bruteforce_decrypt")
+    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_handle_event.reset_mock()
 
-                def get_event_data(obj, event):
-                    obj.data = "encrypted"
+            def get_event_data(obj, event):
+                obj.data = "encrypted"
 
-                mock_handle_event.side_effect = get_event_data
-                mock_decrypt.side_effect = lambda d, **kw: "plaintext"
-                event = Mock()
-                ceg = self.get_obj()
-                ceg.handle_event(event)
-                mock_handle_event.assert_called_with(ceg, event)
-                mock_decrypt.assert_called_with("encrypted")
-                self.assertEqual(ceg.data, "plaintext")
+            mock_handle_event.side_effect = get_event_data
+            mock_decrypt.side_effect = lambda d, **kw: "plaintext"
+            event = Mock()
+            ceg = self.get_obj()
+            ceg.handle_event(event)
+            mock_handle_event.assert_called_with(ceg, event)
+            mock_decrypt.assert_called_with("encrypted")
+            self.assertEqual(ceg.data, "plaintext")
 
-                reset()
-                mock_decrypt.side_effect = EVPError
-                self.assertRaises(PluginExecutionError,
-                                  ceg.handle_event, event)
-            inner()
+            reset()
+            mock_decrypt.side_effect = EVPError
+            self.assertRaises(PluginExecutionError,
+                              ceg.handle_event, event)
+        inner()
 
-            # to perform the tests from the parent test object, we
-            # make bruteforce_decrypt just return whatever data was
-            # given to it
-            mock_decrypt.side_effect = lambda d, **kw: d
-            TestCfgGenerator.test_handle_event(self)
+        # to perform the tests from the parent test object, we
+        # make bruteforce_decrypt just return whatever data was
+        # given to it
+        mock_decrypt.side_effect = lambda d, **kw: d
+        TestCfgGenerator.test_handle_event(self)
 
-        def test_get_data(self):
-            ceg = self.get_obj()
-            ceg.data = None
-            entry = lxml.etree.Element("Path", name="/test.txt")
-            metadata = Mock()
+    def test_get_data(self):
+        ceg = self.get_obj()
+        ceg.data = None
+        entry = lxml.etree.Element("Path", name="/test.txt")
+        metadata = Mock()
 
-            self.assertRaises(PluginExecutionError,
-                              ceg.get_data, entry, metadata)
+        self.assertRaises(PluginExecutionError,
+                          ceg.get_data, entry, metadata)
 
-            TestCfgGenerator.test_get_data(self)
+        TestCfgGenerator.test_get_data(self)
diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgEncryptedGenshiGenerator.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgEncryptedGenshiGenerator.py
index 25d2fb83b..0b74e4a60 100644
--- a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgEncryptedGenshiGenerator.py
+++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestCfg/TestCfgEncryptedGenshiGenerator.py
@@ -18,10 +18,9 @@ from TestServer.TestPlugins.TestCfg.TestCfgGenshiGenerator import \
     TestCfgGenshiGenerator
 
 
-if can_skip or HAS_CRYPTO:
-    class TestCfgEncryptedGenshiGenerator(TestCfgGenshiGenerator):
-        test_obj = CfgEncryptedGenshiGenerator
+class TestCfgEncryptedGenshiGenerator(TestCfgGenshiGenerator):
+    test_obj = CfgEncryptedGenshiGenerator
 
-        @skipUnless(HAS_CRYPTO, "Encryption libraries not found, skipping")
-        def setUp(self):
-            TestCfgGenshiGenerator.setUp(self)
+    @skipUnless(HAS_CRYPTO, "Encryption libraries not found, skipping")
+    def setUp(self):
+        TestCfgGenshiGenerator.setUp(self)
diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestMetadata.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestMetadata.py
index 20d752afc..290edb83a 100644
--- a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestMetadata.py
+++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestMetadata.py
@@ -110,99 +110,98 @@ class TestMetadataDB(DBModelTestCase):
         models = [MetadataClientModel]
 
 
-if HAS_DJANGO or can_skip:
-    class TestClientVersions(TestDatabaseBacked):
-        test_clients = dict(client1="1.2.0",
-                            client2="1.2.2",
-                            client3="1.3.0pre1",
-                            client4="1.1.0",
-                            client5=None,
-                            client6=None)
-
-        @skipUnless(HAS_DJANGO, "Django not found")
-        def setUp(self):
-            TestDatabaseBacked.setUp(self)
-            self.test_obj = ClientVersions
-            syncdb(TestMetadataDB)
-            for client, version in self.test_clients.items():
-                MetadataClientModel(hostname=client, version=version).save()
-
-        def test__contains(self):
-            v = self.get_obj()
-            self.assertIn("client1", v)
-            self.assertIn("client5", v)
-            self.assertNotIn("client__contains", v)
-
-        def test_keys(self):
-            v = self.get_obj()
-            self.assertItemsEqual(self.test_clients.keys(), v.keys())
-
-        def test__setitem(self):
-            v = self.get_obj()
-
-            # test setting version of existing client
-            v["client1"] = "1.2.3"
-            self.assertIn("client1", v)
-            self.assertEqual(v['client1'], "1.2.3")
-            client = MetadataClientModel.objects.get(hostname="client1")
-            self.assertEqual(client.version, "1.2.3")
-
-            # test adding new client
-            new = "client__setitem"
-            v[new] = "1.3.0"
-            self.assertIn(new, v)
-            self.assertEqual(v[new], "1.3.0")
-            client = MetadataClientModel.objects.get(hostname=new)
-            self.assertEqual(client.version, "1.3.0")
-
-            # test adding new client with no version
-            new2 = "client__setitem_2"
-            v[new2] = None
-            self.assertIn(new2, v)
-            self.assertEqual(v[new2], None)
-            client = MetadataClientModel.objects.get(hostname=new2)
-            self.assertEqual(client.version, None)
-
-        def test__getitem(self):
-            v = self.get_obj()
-
-            # test getting existing client
-            self.assertEqual(v['client2'], "1.2.2")
-            self.assertIsNone(v['client5'])
-
-            # test exception on nonexistent client
-            expected = KeyError
-            try:
-                v['clients__getitem']
-            except expected:
-                pass
-            except:
-                err = sys.exc_info()[1]
-                self.assertFalse(True, "%s raised instead of %s" %
-                                 (err.__class__.__name__,
-                                  expected.__class__.__name__))
-            else:
-                self.assertFalse(True,
-                                 "%s not raised" % expected.__class__.__name__)
+class TestClientVersions(TestDatabaseBacked):
+    test_clients = dict(client1="1.2.0",
+                        client2="1.2.2",
+                        client3="1.3.0pre1",
+                        client4="1.1.0",
+                        client5=None,
+                        client6=None)
+
+    @skipUnless(HAS_DJANGO, "Django not found")
+    def setUp(self):
+        TestDatabaseBacked.setUp(self)
+        self.test_obj = ClientVersions
+        syncdb(TestMetadataDB)
+        for client, version in self.test_clients.items():
+            MetadataClientModel(hostname=client, version=version).save()
+
+    def test__contains(self):
+        v = self.get_obj()
+        self.assertIn("client1", v)
+        self.assertIn("client5", v)
+        self.assertNotIn("client__contains", v)
+
+    def test_keys(self):
+        v = self.get_obj()
+        self.assertItemsEqual(self.test_clients.keys(), v.keys())
+
+    def test__setitem(self):
+        v = self.get_obj()
+
+        # test setting version of existing client
+        v["client1"] = "1.2.3"
+        self.assertIn("client1", v)
+        self.assertEqual(v['client1'], "1.2.3")
+        client = MetadataClientModel.objects.get(hostname="client1")
+        self.assertEqual(client.version, "1.2.3")
+
+        # test adding new client
+        new = "client__setitem"
+        v[new] = "1.3.0"
+        self.assertIn(new, v)
+        self.assertEqual(v[new], "1.3.0")
+        client = MetadataClientModel.objects.get(hostname=new)
+        self.assertEqual(client.version, "1.3.0")
+
+        # test adding new client with no version
+        new2 = "client__setitem_2"
+        v[new2] = None
+        self.assertIn(new2, v)
+        self.assertEqual(v[new2], None)
+        client = MetadataClientModel.objects.get(hostname=new2)
+        self.assertEqual(client.version, None)
+
+    def test__getitem(self):
+        v = self.get_obj()
+
+        # test getting existing client
+        self.assertEqual(v['client2'], "1.2.2")
+        self.assertIsNone(v['client5'])
+
+        # test exception on nonexistent client
+        expected = KeyError
+        try:
+            v['clients__getitem']
+        except expected:
+            pass
+        except:
+            err = sys.exc_info()[1]
+            self.assertFalse(True, "%s raised instead of %s" %
+                             (err.__class__.__name__,
+                              expected.__class__.__name__))
+        else:
+            self.assertFalse(True,
+                             "%s not raised" % expected.__class__.__name__)
 
-        def test__len(self):
-            v = self.get_obj()
-            self.assertEqual(len(v), MetadataClientModel.objects.count())
+    def test__len(self):
+        v = self.get_obj()
+        self.assertEqual(len(v), MetadataClientModel.objects.count())
 
-        def test__iter(self):
-            v = self.get_obj()
-            self.assertItemsEqual([h for h in iter(v)], v.keys())
+    def test__iter(self):
+        v = self.get_obj()
+        self.assertItemsEqual([h for h in iter(v)], v.keys())
 
-        def test__delitem(self):
-            v = self.get_obj()
+    def test__delitem(self):
+        v = self.get_obj()
 
-            # test adding new client
-            new = "client__delitem"
-            v[new] = "1.3.0"
+        # test adding new client
+        new = "client__delitem"
+        v[new] = "1.3.0"
 
-            del v[new]
-            self.assertIn(new, v)
-            self.assertIsNone(v[new])
+        del v[new]
+        self.assertIn(new, v)
+        self.assertIsNone(v[new])
 
 
 class TestXMLMetadataConfig(TestXMLFileBacked):
@@ -1354,12 +1353,7 @@ class TestMetadataBase(TestMetadata):
 class TestMetadata_NoClientsXML(TestMetadataBase):
     """ test Metadata without a clients.xml. we have to disable or
     override tests that rely on client options """
-    # only run these tests if it's possible to skip tests or if we
-    # have django.  otherwise they'll all get run because our fake
-    # skipping decorators for python < 2.7 won't work when they
-    # decorate setUp()
-    if can_skip or HAS_DJANGO:
-        __test__ = True
+    __test__ = True
 
     def load_groups_data(self, metadata=None, xdata=None):
         if metadata is None:
@@ -1523,12 +1517,7 @@ class TestMetadata_NoClientsXML(TestMetadataBase):
 
 class TestMetadata_ClientsXML(TestMetadataBase):
     """ test Metadata with a clients.xml.  """
-    # only run these tests if it's possible to skip tests or if we
-    # have django.  otherwise they'll all get run because our fake
-    # skipping decorators for python < 2.7 won't work when they
-    # decorate setUp()
-    if can_skip or HAS_DJANGO:
-        __test__ = True
+    __test__ = True
 
     def load_clients_data(self, metadata=None, xdata=None):
         if metadata is None:
diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestProperties.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestProperties.py
index 9fa2cc4db..159dc6e66 100644
--- a/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestProperties.py
+++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugins/TestProperties.py
@@ -89,86 +89,84 @@ class TestPropertyFile(Bcfg2TestCase):
         mock_copy.assert_called_with(pf)
 
 
-if can_skip or HAS_JSON:
-    class TestJSONPropertyFile(TestFileBacked, TestPropertyFile):
-        test_obj = JSONPropertyFile
-
-        @skipUnless(HAS_JSON, "JSON libraries not found, skipping")
-        def setUp(self):
-            TestFileBacked.setUp(self)
-            TestPropertyFile.setUp(self)
-
-        @patch("%s.loads" % JSON)
-        def test_Index(self, mock_loads):
-            pf = self.get_obj()
-            pf.Index()
-            mock_loads.assert_called_with(pf.data)
-            self.assertEqual(pf.json, mock_loads.return_value)
-
-            mock_loads.reset_mock()
-            mock_loads.side_effect = ValueError
-            self.assertRaises(PluginExecutionError, pf.Index)
-            mock_loads.assert_called_with(pf.data)
-
-        @patch("%s.dump" % JSON)
-        @patch("%s.open" % builtins)
-        def test__write(self, mock_open, mock_dump):
-            pf = self.get_obj()
-            self.assertTrue(pf._write())
-            mock_open.assert_called_with(pf.name, 'wb')
-            mock_dump.assert_called_with(pf.json, mock_open.return_value)
-
-        @patch("%s.dumps" % JSON)
-        def test_validate_data(self, mock_dumps):
-            pf = self.get_obj()
-            pf.validate_data()
-            mock_dumps.assert_called_with(pf.json)
-
-            mock_dumps.reset_mock()
-            mock_dumps.side_effect = ValueError
-            self.assertRaises(PluginExecutionError, pf.validate_data)
-            mock_dumps.assert_called_with(pf.json)
-
-
-if can_skip or HAS_YAML:
-    class TestYAMLPropertyFile(TestFileBacked, TestPropertyFile):
-        test_obj = YAMLPropertyFile
-
-        @skipUnless(HAS_YAML, "YAML libraries not found, skipping")
-        def setUp(self):
-            TestFileBacked.setUp(self)
-            TestPropertyFile.setUp(self)
-
-        @patch("yaml.load")
-        def test_Index(self, mock_load):
-            pf = self.get_obj()
-            pf.Index()
-            mock_load.assert_called_with(pf.data)
-            self.assertEqual(pf.yaml, mock_load.return_value)
-
-            mock_load.reset_mock()
-            mock_load.side_effect = yaml.YAMLError
-            self.assertRaises(PluginExecutionError, pf.Index)
-            mock_load.assert_called_with(pf.data)
-
-        @patch("yaml.dump")
-        @patch("%s.open" % builtins)
-        def test__write(self, mock_open, mock_dump):
-            pf = self.get_obj()
-            self.assertTrue(pf._write())
-            mock_open.assert_called_with(pf.name, 'wb')
-            mock_dump.assert_called_with(pf.yaml, mock_open.return_value)
-
-        @patch("yaml.dump")
-        def test_validate_data(self, mock_dump):
-            pf = self.get_obj()
-            pf.validate_data()
-            mock_dump.assert_called_with(pf.yaml)
-
-            mock_dump.reset_mock()
-            mock_dump.side_effect = yaml.YAMLError
-            self.assertRaises(PluginExecutionError, pf.validate_data)
-            mock_dump.assert_called_with(pf.yaml)
+class TestJSONPropertyFile(TestFileBacked, TestPropertyFile):
+    test_obj = JSONPropertyFile
+
+    @skipUnless(HAS_JSON, "JSON libraries not found, skipping")
+    def setUp(self):
+        TestFileBacked.setUp(self)
+        TestPropertyFile.setUp(self)
+
+    @patch("%s.loads" % JSON)
+    def test_Index(self, mock_loads):
+        pf = self.get_obj()
+        pf.Index()
+        mock_loads.assert_called_with(pf.data)
+        self.assertEqual(pf.json, mock_loads.return_value)
+
+        mock_loads.reset_mock()
+        mock_loads.side_effect = ValueError
+        self.assertRaises(PluginExecutionError, pf.Index)
+        mock_loads.assert_called_with(pf.data)
+
+    @patch("%s.dump" % JSON)
+    @patch("%s.open" % builtins)
+    def test__write(self, mock_open, mock_dump):
+        pf = self.get_obj()
+        self.assertTrue(pf._write())
+        mock_open.assert_called_with(pf.name, 'wb')
+        mock_dump.assert_called_with(pf.json, mock_open.return_value)
+
+    @patch("%s.dumps" % JSON)
+    def test_validate_data(self, mock_dumps):
+        pf = self.get_obj()
+        pf.validate_data()
+        mock_dumps.assert_called_with(pf.json)
+
+        mock_dumps.reset_mock()
+        mock_dumps.side_effect = ValueError
+        self.assertRaises(PluginExecutionError, pf.validate_data)
+        mock_dumps.assert_called_with(pf.json)
+
+
+class TestYAMLPropertyFile(TestFileBacked, TestPropertyFile):
+    test_obj = YAMLPropertyFile
+
+    @skipUnless(HAS_YAML, "YAML libraries not found, skipping")
+    def setUp(self):
+        TestFileBacked.setUp(self)
+        TestPropertyFile.setUp(self)
+
+    @patch("yaml.load")
+    def test_Index(self, mock_load):
+        pf = self.get_obj()
+        pf.Index()
+        mock_load.assert_called_with(pf.data)
+        self.assertEqual(pf.yaml, mock_load.return_value)
+
+        mock_load.reset_mock()
+        mock_load.side_effect = yaml.YAMLError
+        self.assertRaises(PluginExecutionError, pf.Index)
+        mock_load.assert_called_with(pf.data)
+
+    @patch("yaml.dump")
+    @patch("%s.open" % builtins)
+    def test__write(self, mock_open, mock_dump):
+        pf = self.get_obj()
+        self.assertTrue(pf._write())
+        mock_open.assert_called_with(pf.name, 'wb')
+        mock_dump.assert_called_with(pf.yaml, mock_open.return_value)
+
+    @patch("yaml.dump")
+    def test_validate_data(self, mock_dump):
+        pf = self.get_obj()
+        pf.validate_data()
+        mock_dump.assert_called_with(pf.yaml)
+
+        mock_dump.reset_mock()
+        mock_dump.side_effect = yaml.YAMLError
+        self.assertRaises(PluginExecutionError, pf.validate_data)
+        mock_dump.assert_called_with(pf.yaml)
 
 
 class TestXMLPropertyFile(TestPropertyFile, TestStructFile):
diff --git a/testsuite/common.py b/testsuite/common.py
index c59444fad..04c446f67 100644
--- a/testsuite/common.py
+++ b/testsuite/common.py
@@ -112,9 +112,6 @@ else:
         return codecs.unicode_escape_decode(s)[0]
 
 
-can_skip = True
-
-
 class Bcfg2TestCase(TestCase):
     """ Base TestCase class that inherits from
     :class:`unittest.TestCase`.  This class adds