style: dnssec tests: import at top, cleaner skip

Signed-off-by: Sebastian Wagner <sebix@sebix.at>

1 files changed, 31 insertions, 32 deletions

diff --git a/tests/test_dnssec.py b/tests/test_dnssec.py
index db3bc97..80bd626 100644
--- a/tests/test_dnssec.py
+++ b/tests/test_dnssec.py
@@ -20,6 +20,12 @@ try:
 except ImportError:
     import unittest
 
+try:
+    import Crypto.Util.number  # pylint: disable=unused-import
+    import_ok = True
+except ImportError:
+    import_ok = False
+
 import dns.dnssec
 import dns.name
 import dns.rdata
@@ -150,34 +156,36 @@ abs_other_ecdsa384_soa = dns.rrset.from_text('example.', 86400, 'IN', 'SOA',
 abs_ecdsa384_soa_rrsig = dns.rrset.from_text('example.', 86400, 'IN', 'RRSIG',
                                              "SOA 14 1 86400 20130929021229 20130921230729 63571 example. CrnCu34EeeRz0fEhL9PLlwjpBKGYW8QjBjFQTwd+ViVLRAS8tNkcDwQE NhSV89NEjj7ze1a/JcCfcJ+/mZgnvH4NHLNg3Tf6KuLZsgs2I4kKQXEk 37oIHravPEOlGYNI")
 
+@unittest.skipUnless(import_ok, "skipping DNSSEC tests because pycrypto is not"
+                                " installed")
 class DNSSECValidatorTestCase(unittest.TestCase):
 
-    @unittest.skipIf(not dns.dnssec._have_pycrypto,
-                     "PyCrypto cannot be imported")
+    @unittest.skipUnless(dns.dnssec._have_pycrypto,
+                         "PyCrypto cannot be imported")
     def testAbsoluteRSAGood(self):
         dns.dnssec.validate(abs_soa, abs_soa_rrsig, abs_keys, None, when)
 
-    @unittest.skipIf(not dns.dnssec._have_pycrypto,
-                     "PyCrypto cannot be imported")
+    @unittest.skipUnless(dns.dnssec._have_pycrypto,
+                         "PyCrypto cannot be imported")
     def testDuplicateKeytag(self):
         dns.dnssec.validate(abs_soa, abs_soa_rrsig, abs_keys_duplicate_keytag, None, when)
 
-    @unittest.skipIf(not dns.dnssec._have_pycrypto,
-                     "PyCrypto cannot be imported")
+    @unittest.skipUnless(dns.dnssec._have_pycrypto,
+                         "PyCrypto cannot be imported")
     def testAbsoluteRSABad(self):
         def bad():
             dns.dnssec.validate(abs_other_soa, abs_soa_rrsig, abs_keys, None,
                                 when)
         self.failUnlessRaises(dns.dnssec.ValidationFailure, bad)
 
-    @unittest.skipIf(not dns.dnssec._have_pycrypto,
-                     "PyCrypto cannot be imported")
+    @unittest.skipUnless(dns.dnssec._have_pycrypto,
+                         "PyCrypto cannot be imported")
     def testRelativeRSAGood(self):
         dns.dnssec.validate(rel_soa, rel_soa_rrsig, rel_keys,
                             abs_dnspython_org, when)
 
-    @unittest.skipIf(not dns.dnssec._have_pycrypto,
-                     "PyCrypto cannot be imported")
+    @unittest.skipUnless(dns.dnssec._have_pycrypto,
+                         "PyCrypto cannot be imported")
     def testRelativeRSABad(self):
         def bad():
             dns.dnssec.validate(rel_other_soa, rel_soa_rrsig, rel_keys,
@@ -188,14 +196,14 @@ class DNSSECValidatorTestCase(unittest.TestCase):
         ds = dns.dnssec.make_ds(abs_dnspython_org, sep_key, 'SHA256')
         self.failUnless(ds == good_ds)
 
-    @unittest.skipIf(not dns.dnssec._have_pycrypto,
-                     "PyCrypto cannot be imported")
+    @unittest.skipUnless(dns.dnssec._have_pycrypto,
+                         "PyCrypto cannot be imported")
     def testAbsoluteDSAGood(self):
         dns.dnssec.validate(abs_dsa_soa, abs_dsa_soa_rrsig, abs_dsa_keys, None,
                             when2)
 
-    @unittest.skipIf(not dns.dnssec._have_pycrypto,
-                     "PyCrypto cannot be imported")
+    @unittest.skipUnless(dns.dnssec._have_pycrypto,
+                         "PyCrypto cannot be imported")
     def testAbsoluteDSABad(self):
         def bad():
             dns.dnssec.validate(abs_other_dsa_soa, abs_dsa_soa_rrsig,
@@ -210,28 +218,28 @@ class DNSSECValidatorTestCase(unittest.TestCase):
         ds = dns.dnssec.make_ds(abs_example, example_sep_key, 'SHA256')
         self.failUnless(ds == example_ds_sha256)
 
-    @unittest.skipIf(not dns.dnssec._have_ecdsa,
-                     "python ECDSA cannot be imported")
+    @unittest.skipUnless(dns.dnssec._have_ecdsa,
+                         "python ECDSA cannot be imported")
     def testAbsoluteECDSA256Good(self):
         dns.dnssec.validate(abs_ecdsa256_soa, abs_ecdsa256_soa_rrsig,
                             abs_ecdsa256_keys, None, when3)
 
-    @unittest.skipIf(not dns.dnssec._have_ecdsa,
-                     "python ECDSA cannot be imported")
+    @unittest.skipUnless(dns.dnssec._have_ecdsa,
+                         "python ECDSA cannot be imported")
     def testAbsoluteECDSA256Bad(self):
         def bad():
             dns.dnssec.validate(abs_other_ecdsa256_soa, abs_ecdsa256_soa_rrsig,
                                 abs_ecdsa256_keys, None, when3)
         self.failUnlessRaises(dns.dnssec.ValidationFailure, bad)
 
-    @unittest.skipIf(not dns.dnssec._have_ecdsa,
-                     "python ECDSA cannot be imported")
+    @unittest.skipUnless(dns.dnssec._have_ecdsa,
+                         "python ECDSA cannot be imported")
     def testAbsoluteECDSA384Good(self):
         dns.dnssec.validate(abs_ecdsa384_soa, abs_ecdsa384_soa_rrsig,
                             abs_ecdsa384_keys, None, when4)
 
-    @unittest.skipIf(not dns.dnssec._have_ecdsa,
-                     "python ECDSA cannot be imported")
+    @unittest.skipUnless(dns.dnssec._have_ecdsa,
+                         "python ECDSA cannot be imported")
     def testAbsoluteECDSA384Bad(self):
         def bad():
             dns.dnssec.validate(abs_other_ecdsa384_soa, abs_ecdsa384_soa_rrsig,
@@ -240,13 +248,4 @@ class DNSSECValidatorTestCase(unittest.TestCase):
 
 
 if __name__ == '__main__':
-    import_ok = False
-    try:
-        import Crypto.Util.number  # pylint: disable=unused-import
-        import_ok = True
-    except ImportError:
-        pass
-    if import_ok:
-        unittest.main()
-    else:
-        print('skipping DNSSEC tests because pycrypto is not installed')
+    unittest.main()