Add test_from_json_hashable

letsencrypt/acme/challenges_test.py

@@ -37,6 +37,10 @@ class SimpleHTTPSTest(unittest.TestCase):
         from letsencrypt.acme.challenges import SimpleHTTPS
         self.assertEqual(self.msg, SimpleHTTPS.from_json(self.jmsg))
 
+    def test_from_json_hashable(self):
+        from letsencrypt.acme.challenges import SimpleHTTPS
+        hash(SimpleHTTPS.from_json(self.jmsg))
+
 
 class SimpleHTTPSResponseTest(unittest.TestCase):
 
@@ -60,6 +64,10 @@ class SimpleHTTPSResponseTest(unittest.TestCase):
         self.assertEqual(
             self.msg, SimpleHTTPSResponse.from_json(self.jmsg))
 
+    def test_from_json_hashable(self):
+        from letsencrypt.acme.challenges import SimpleHTTPSResponse
+        hash(SimpleHTTPSResponse.from_json(self.jmsg))
+
 
 class DVSNITest(unittest.TestCase):
 
@@ -86,6 +94,10 @@ class DVSNITest(unittest.TestCase):
         from letsencrypt.acme.challenges import DVSNI
         self.assertEqual(self.msg, DVSNI.from_json(self.jmsg))
 
+    def test_from_json_hashable(self):
+        from letsencrypt.acme.challenges import DVSNI
+        hash(DVSNI.from_json(self.jmsg))
+
     def test_from_json_invalid_r_length(self):
         from letsencrypt.acme.challenges import DVSNI
         self.jmsg['r'] = 'abcd'
@@ -131,6 +143,10 @@ class DVSNIResponseTest(unittest.TestCase):
         from letsencrypt.acme.challenges import DVSNIResponse
         self.assertEqual(self.msg, DVSNIResponse.from_json(self.jmsg))
 
+    def test_from_json_hashable(self):
+        from letsencrypt.acme.challenges import DVSNIResponse
+        hash(DVSNIResponse.from_json(self.jmsg))
+
 
 class RecoveryContactTest(unittest.TestCase):
 
@@ -154,6 +170,10 @@ class RecoveryContactTest(unittest.TestCase):
         from letsencrypt.acme.challenges import RecoveryContact
         self.assertEqual(self.msg, RecoveryContact.from_json(self.jmsg))
 
+    def test_from_json_hashable(self):
+        from letsencrypt.acme.challenges import RecoveryContact
+        hash(RecoveryContact.from_json(self.jmsg))
+
     def test_json_without_optionals(self):
         del self.jmsg['activationURL']
         del self.jmsg['successURL']
@@ -183,6 +203,10 @@ class RecoveryContactResponseTest(unittest.TestCase):
         self.assertEqual(
             self.msg, RecoveryContactResponse.from_json(self.jmsg))
 
+    def test_from_json_hashable(self):
+        from letsencrypt.acme.challenges import RecoveryContactResponse
+        hash(RecoveryContactResponse.from_json(self.jmsg))
+
     def test_json_without_optionals(self):
         del self.jmsg['token']
 
@@ -207,6 +231,10 @@ class RecoveryTokenTest(unittest.TestCase):
         from letsencrypt.acme.challenges import RecoveryToken
         self.assertEqual(self.msg, RecoveryToken.from_json(self.jmsg))
 
+    def test_from_json_hashable(self):
+        from letsencrypt.acme.challenges import RecoveryToken
+        hash(RecoveryToken.from_json(self.jmsg))
+
 
 class RecoveryTokenResponseTest(unittest.TestCase):
 
@@ -223,6 +251,10 @@ class RecoveryTokenResponseTest(unittest.TestCase):
         self.assertEqual(
             self.msg, RecoveryTokenResponse.from_json(self.jmsg))
 
+    def test_from_json_hashable(self):
+        from letsencrypt.acme.challenges import RecoveryTokenResponse
+        hash(RecoveryTokenResponse.from_json(self.jmsg))
+
     def test_json_without_optionals(self):
         del self.jmsg['token']
 
@@ -276,6 +308,10 @@ class ProofOfPossessionHintsTest(unittest.TestCase):
         self.assertEqual(
             self.msg, ProofOfPossession.Hints.from_json(self.jmsg_from))
 
+    def test_from_json_hashable(self):
+        from letsencrypt.acme.challenges import ProofOfPossession
+        hash(ProofOfPossession.Hints.from_json(self.jmsg_from))
+
     def test_json_without_optionals(self):
         for optional in ['certFingerprints', 'certs', 'subjectKeyIdentifiers',
                          'serialNumbers', 'issuers', 'authorizedFor']:
@@ -328,6 +364,10 @@ class ProofOfPossessionTest(unittest.TestCase):
         self.assertEqual(
             self.msg, ProofOfPossession.from_json(self.jmsg_from))
 
+    def test_from_json_hashable(self):
+        from letsencrypt.acme.challenges import ProofOfPossession
+        hash(ProofOfPossession.from_json(self.jmsg_from))
+
 
 class ProofOfPossessionResponseTest(unittest.TestCase):
 
@@ -371,6 +411,10 @@ class ProofOfPossessionResponseTest(unittest.TestCase):
         self.assertEqual(
             self.msg, ProofOfPossessionResponse.from_json(self.jmsg_from))
 
+    def test_from_json_hashable(self):
+        from letsencrypt.acme.challenges import ProofOfPossessionResponse
+        hash(ProofOfPossessionResponse.from_json(self.jmsg_from))
+
 
 class DNSTest(unittest.TestCase):
 
@@ -386,6 +430,10 @@ class DNSTest(unittest.TestCase):
         from letsencrypt.acme.challenges import DNS
         self.assertEqual(self.msg, DNS.from_json(self.jmsg))
 
+    def test_from_json_hashable(self):
+        from letsencrypt.acme.challenges import DNS
+        hash(DNS.from_json(self.jmsg))
+
 
 class DNSResponseTest(unittest.TestCase):
 
@@ -401,6 +449,10 @@ class DNSResponseTest(unittest.TestCase):
         from letsencrypt.acme.challenges import DNSResponse
         self.assertEqual(self.msg, DNSResponse.from_json(self.jmsg))
 
+    def test_from_json_hashable(self):
+        from letsencrypt.acme.challenges import DNSResponse
+        hash(DNSResponse.from_json(self.jmsg))
+
 
 if __name__ == '__main__':
     unittest.main()

letsencrypt/acme/jose/jwk_test.py

@@ -29,6 +29,10 @@ class JWKOctTest(unittest.TestCase):
         from letsencrypt.acme.jose.jwk import JWKOct
         self.assertEqual(self.jwk, JWKOct.from_json(self.jobj))
 
+    def test_from_json_hashable(self):
+        from letsencrypt.acme.jose.jwk import JWKOct
+        hash(JWKOct.from_json(self.jobj))
+
     def test_load(self):
         from letsencrypt.acme.jose.jwk import JWKOct
         self.assertEqual(self.jwk, JWKOct.load('foo'))
@@ -86,6 +90,10 @@ class JWKRSATest(unittest.TestCase):
         # TODO: fix schemata to allow RSA512
         #self.assertEqual(self.jwk512, JWK.from_json(self.jwk512json))
 
+    def test_from_json_hashable(self):
+        from letsencrypt.acme.jose.jwk import JWK
+        hash(JWK.from_json(self.jwk256json))
+
     def test_from_json_non_schema_errors(self):
         # valid against schema, but still failing
         from letsencrypt.acme.jose.jwk import JWK

letsencrypt/acme/jose/jws_test.py

@@ -196,6 +196,10 @@ class JWSTest(unittest.TestCase):
         self.assertRaises(errors.DeserializationError, JWS.from_json,
                           {'signatures': (), 'signature': 'foo'})
 
+    def test_from_json_hashable(self):
+        from letsencrypt.acme.jose.jws import JWS
+        hash(JWS.from_json(self.mixed.fully_serialize()))
+
 
 class CLITest(unittest.TestCase):
 

letsencrypt/acme/messages2_test.py

@@ -39,6 +39,10 @@ class ErrorTest(unittest.TestCase):
         self.assertEqual(
             'The request message was malformed', self.error.description)
 
+    def test_from_json_hashable(self):
+        from letsencrypt.acme.messages2 import Error
+        hash(Error.from_json(self.error.fully_serialize()))
+
 
 class ConstantTest(unittest.TestCase):
     """Tests for letsencrypt.acme.messages2._Constant."""
@@ -61,6 +65,9 @@ class ConstantTest(unittest.TestCase):
         self.assertRaises(
             jose.DeserializationError, self.MockConstant.from_json, 'c')
 
+    def test_from_json_hashable(self):
+        hash(self.MockConstant.from_json('a'))
+
     def test_repr(self):
         self.assertEqual('MockConstant(a)', repr(self.const_a))
         self.assertEqual('MockConstant(b)', repr(self.const_b))
@@ -99,10 +106,14 @@ class ChallengeBodyTest(unittest.TestCase):
     def test_to_json(self):
         self.assertEqual(self.jobj_to, self.challb.to_json())
 
-    def test_fields_from_json(self):
+    def test_from_json(self):
         from letsencrypt.acme.messages2 import ChallengeBody
         self.assertEqual(self.challb, ChallengeBody.from_json(self.jobj_from))
 
+    def test_from_json_hashable(self):
+        from letsencrypt.acme.messages2 import ChallengeBody
+        hash(ChallengeBody.from_json(self.jobj_from))
+
 
 class AuthorizationTest(unittest.TestCase):
     """Tests for letsencrypt.acme.messages2.Authorization."""
@@ -139,6 +150,10 @@ class AuthorizationTest(unittest.TestCase):
         from letsencrypt.acme.messages2 import Authorization
         Authorization.from_json(self.jobj_from)
 
+    def test_from_json_hashable(self):
+        from letsencrypt.acme.messages2 import Authorization
+        hash(Authorization.from_json(self.jobj_from))
+
     def test_resolved_combinations(self):
         self.assertEqual(self.authz.resolved_combinations, (
             (self.challbs[0], self.challbs[2]),
@@ -167,6 +182,10 @@ class RevocationTest(unittest.TestCase):
         self.assertEqual(self.jobj_now, self.rev_now.to_json())
         self.assertEqual(self.jobj_date, self.rev_date.to_json())
 
+    def test_from_json_hashable(self):
+        from letsencrypt.acme.messages2 import Revocation
+        hash(Revocation.from_json(self.rev_now.fully_serialize()))
+
 
 if __name__ == '__main__':
     unittest.main()