Initial type signatures

1 files changed, 20 insertions, 23 deletions

diff --git a/tests/test_dnssec.py b/tests/test_dnssec.py
index 78b1cdc..bec6ede 100644
--- a/tests/test_dnssec.py
+++ b/tests/test_dnssec.py
@@ -15,10 +15,7 @@
 
 from __future__ import print_function
 
-try:
-    import unittest2 as unittest
-except ImportError:
-    import unittest
+import unittest
 
 import dns.dnssec
 import dns.name
@@ -156,74 +153,74 @@ abs_ecdsa384_soa_rrsig = dns.rrset.from_text('example.', 86400, 'IN', 'RRSIG',
                      "Pycryptodome cannot be imported")
 class DNSSECValidatorTestCase(unittest.TestCase):
 
-    def testAbsoluteRSAGood(self):
+    def testAbsoluteRSAGood(self): # type: () -> None
         dns.dnssec.validate(abs_soa, abs_soa_rrsig, abs_keys, None, when)
 
-    def testDuplicateKeytag(self):
+    def testDuplicateKeytag(self): # type: () -> None
         dns.dnssec.validate(abs_soa, abs_soa_rrsig, abs_keys_duplicate_keytag, None, when)
 
-    def testAbsoluteRSABad(self):
-        def bad():
+    def testAbsoluteRSABad(self): # type: () -> None
+        def bad(): # type: () -> None
             dns.dnssec.validate(abs_other_soa, abs_soa_rrsig, abs_keys, None,
                                 when)
         self.failUnlessRaises(dns.dnssec.ValidationFailure, bad)
 
-    def testRelativeRSAGood(self):
+    def testRelativeRSAGood(self): # type: () -> None
         dns.dnssec.validate(rel_soa, rel_soa_rrsig, rel_keys,
                             abs_dnspython_org, when)
 
-    def testRelativeRSABad(self):
-        def bad():
+    def testRelativeRSABad(self): # type: () -> None
+        def bad(): # type: () -> None
             dns.dnssec.validate(rel_other_soa, rel_soa_rrsig, rel_keys,
                                 abs_dnspython_org, when)
         self.failUnlessRaises(dns.dnssec.ValidationFailure, bad)
 
-    def testMakeSHA256DS(self):
+    def testMakeSHA256DS(self): # type: () -> None
         ds = dns.dnssec.make_ds(abs_dnspython_org, sep_key, 'SHA256')
         self.failUnless(ds == good_ds)
 
-    def testAbsoluteDSAGood(self):
+    def testAbsoluteDSAGood(self): # type: () -> None
         dns.dnssec.validate(abs_dsa_soa, abs_dsa_soa_rrsig, abs_dsa_keys, None,
                             when2)
 
-    def testAbsoluteDSABad(self):
-        def bad():
+    def testAbsoluteDSABad(self): # type: () -> None
+        def bad(): # type: () -> None
             dns.dnssec.validate(abs_other_dsa_soa, abs_dsa_soa_rrsig,
                                 abs_dsa_keys, None, when2)
         self.failUnlessRaises(dns.dnssec.ValidationFailure, bad)
 
-    def testMakeExampleSHA1DS(self):
+    def testMakeExampleSHA1DS(self): # type: () -> None
         ds = dns.dnssec.make_ds(abs_example, example_sep_key, 'SHA1')
         self.failUnless(ds == example_ds_sha1)
 
-    def testMakeExampleSHA256DS(self):
+    def testMakeExampleSHA256DS(self): # type: () -> None
         ds = dns.dnssec.make_ds(abs_example, example_sep_key, 'SHA256')
         self.failUnless(ds == example_ds_sha256)
 
     @unittest.skipUnless(dns.dnssec._have_ecdsa,
                          "python ECDSA cannot be imported")
-    def testAbsoluteECDSA256Good(self):
+    def testAbsoluteECDSA256Good(self): # type: () -> None
         dns.dnssec.validate(abs_ecdsa256_soa, abs_ecdsa256_soa_rrsig,
                             abs_ecdsa256_keys, None, when3)
 
     @unittest.skipUnless(dns.dnssec._have_ecdsa,
                          "python ECDSA cannot be imported")
-    def testAbsoluteECDSA256Bad(self):
-        def bad():
+    def testAbsoluteECDSA256Bad(self): # type: () -> None
+        def bad(): # type: () -> None
             dns.dnssec.validate(abs_other_ecdsa256_soa, abs_ecdsa256_soa_rrsig,
                                 abs_ecdsa256_keys, None, when3)
         self.failUnlessRaises(dns.dnssec.ValidationFailure, bad)
 
     @unittest.skipUnless(dns.dnssec._have_ecdsa,
                          "python ECDSA cannot be imported")
-    def testAbsoluteECDSA384Good(self):
+    def testAbsoluteECDSA384Good(self): # type: () -> None
         dns.dnssec.validate(abs_ecdsa384_soa, abs_ecdsa384_soa_rrsig,
                             abs_ecdsa384_keys, None, when4)
 
     @unittest.skipUnless(dns.dnssec._have_ecdsa,
                          "python ECDSA cannot be imported")
-    def testAbsoluteECDSA384Bad(self):
-        def bad():
+    def testAbsoluteECDSA384Bad(self): # type: () -> None
+        def bad(): # type: () -> None
             dns.dnssec.validate(abs_other_ecdsa384_soa, abs_ecdsa384_soa_rrsig,
                                 abs_ecdsa384_keys, None, when4)
         self.failUnlessRaises(dns.dnssec.ValidationFailure, bad)