add typing with mypy

5 files changed, 48 insertions, 28 deletions

diff --git a/tests/test_itsdangerous/test_jws.py b/tests/test_itsdangerous/test_jws.py
index 1e268d6..6ee8df8 100644
--- a/tests/test_itsdangerous/test_jws.py
+++ b/tests/test_itsdangerous/test_jws.py
@@ -22,10 +22,10 @@ class TestJWSSerializer(TestSerializer):
 
         return factory
 
-    test_signer_cls = None
-    test_signer_kwargs = None
-    test_fallback_signers = None
-    test_iter_unsigners = None
+    test_signer_cls = None  # type: ignore
+    test_signer_kwargs = None  # type: ignore
+    test_fallback_signers = None  # type: ignore
+    test_iter_unsigners = None  # type: ignore
 
     @pytest.mark.parametrize("algorithm_name", ("HS256", "HS384", "HS512", "none"))
     def test_algorithm(self, serializer_factory, algorithm_name):
diff --git a/tests/test_itsdangerous/test_serializer.py b/tests/test_itsdangerous/test_serializer.py
index fcd0ab2..cdc4191 100644
--- a/tests/test_itsdangerous/test_serializer.py
+++ b/tests/test_itsdangerous/test_serializer.py
@@ -3,16 +3,31 @@ import pickle
 from functools import partial
 from io import BytesIO
 from io import StringIO
+from typing import Any
+from typing import cast
+from typing import IO
+from typing import overload
+from typing import Union
 
 import pytest
 
-from itsdangerous import Signer
 from itsdangerous.exc import BadPayload
 from itsdangerous.exc import BadSignature
 from itsdangerous.serializer import Serializer
+from itsdangerous.signer import Signer
 
 
-def coerce_str(ref, s):
+@overload
+def coerce_str(ref: str, s: str) -> str:
+    ...
+
+
+@overload
+def coerce_str(ref: bytes, s: str) -> bytes:
+    ...
+
+
+def coerce_str(ref: Union[str, bytes], s: str) -> Union[str, bytes]:
     if isinstance(ref, bytes):
         return s.encode("utf8")
 
@@ -35,7 +50,7 @@ class TestSerializer:
     @pytest.mark.parametrize(
         "value", (None, True, "str", "text", [1, 2, 3], {"id": 42})
     )
-    def test_serializer(self, serializer, value):
+    def test_serializer(self, serializer: Serializer, value: Any):
         assert serializer.loads(serializer.dumps(value)) == value
 
     @pytest.mark.parametrize(
@@ -47,7 +62,7 @@ class TestSerializer:
             lambda s: s.replace(coerce_str(s, "."), coerce_str(s, "")),
         ),
     )
-    def test_changed_value(self, serializer, value, transform):
+    def test_changed_value(self, serializer: Serializer, value: Any, transform):
         signed = serializer.dumps(value)
         assert serializer.loads(signed) == value
         changed = transform(signed)
@@ -55,17 +70,18 @@ class TestSerializer:
         with pytest.raises(BadSignature):
             serializer.loads(changed)
 
-    def test_bad_signature_exception(self, serializer, value):
+    def test_bad_signature_exception(self, serializer: Serializer, value: Any):
         bad_signed = serializer.dumps(value)[:-1]
 
         with pytest.raises(BadSignature) as exc_info:
             serializer.loads(bad_signed)
 
-        assert serializer.load_payload(exc_info.value.payload) == value
+        payload = cast(bytes, exc_info.value.payload)
+        assert serializer.load_payload(payload) == value
 
-    def test_bad_payload_exception(self, serializer, value):
+    def test_bad_payload_exception(self, serializer: Serializer, value: Any):
         original = serializer.dumps(value)
-        payload = original.rsplit(coerce_str(original, "."), 1)[0]
+        payload = original.rsplit(coerce_str(original, "."), 1)[0]  # type: ignore
         bad = serializer.make_signer().sign(payload[:-1])
 
         with pytest.raises(BadPayload) as exc_info:
@@ -73,18 +89,18 @@ class TestSerializer:
 
         assert exc_info.value.original_error is not None
 
-    def test_loads_unsafe(self, serializer, value):
+    def test_loads_unsafe(self, serializer: Serializer, value: Any):
         signed = serializer.dumps(value)
         assert serializer.loads_unsafe(signed) == (True, value)
 
         bad_signed = signed[:-1]
         assert serializer.loads_unsafe(bad_signed) == (False, value)
 
-        payload = signed.rsplit(coerce_str(signed, "."), 1)[0]
+        payload = signed.rsplit(coerce_str(signed, "."), 1)[0]  # type: ignore
         bad_payload = serializer.make_signer().sign(payload[:-1])[:-1]
         assert serializer.loads_unsafe(bad_payload) == (False, None)
 
-        class BadUnsign(serializer.signer):
+        class BadUnsign(serializer.signer):  # type: ignore
             def unsign(self, signed_value, *args, **kwargs):
                 try:
                     return super().unsign(signed_value, *args, **kwargs)
@@ -95,15 +111,17 @@ class TestSerializer:
         serializer.signer = BadUnsign
         assert serializer.loads_unsafe(bad_signed) == (False, None)
 
-    def test_file(self, serializer, value):
-        f = BytesIO() if isinstance(serializer.dumps(value), bytes) else StringIO()
+    def test_file(self, serializer: Serializer, value: Any):
+        f = cast(
+            IO, BytesIO() if isinstance(serializer.dumps(value), bytes) else StringIO()
+        )
         serializer.dump(value, f)
         f.seek(0)
         assert serializer.load(f) == value
         f.seek(0)
         assert serializer.load_unsafe(f) == (True, value)
 
-    def test_alt_salt(self, serializer, value):
+    def test_alt_salt(self, serializer: Serializer, value: Any):
         signed = serializer.dumps(value, salt="other")
 
         with pytest.raises(BadSignature):
@@ -111,15 +129,17 @@ class TestSerializer:
 
         assert serializer.loads(signed, salt="other") == value
 
-    def test_signer_cls(self, serializer_factory, serializer, value):
-        class Other(serializer.signer):
+    def test_signer_cls(self, serializer_factory, serializer: Serializer, value: Any):
+        class Other(serializer.signer):  # type: ignore
             default_key_derivation = "hmac"
 
         other = serializer_factory(signer=Other)
         assert other.loads(other.dumps(value)) == value
         assert other.dumps(value) != serializer.dumps(value)
 
-    def test_signer_kwargs(self, serializer_factory, serializer, value):
+    def test_signer_kwargs(
+        self, serializer_factory, serializer: Serializer, value: Any
+    ):
         other = serializer_factory(signer_kwargs={"key_derivation": "hmac"})
         assert other.loads(other.dumps(value)) == value
         assert other.dumps("value") != serializer.dumps("value")
@@ -134,7 +154,7 @@ class TestSerializer:
 
         assert serializer.loads(serializer.dumps({(): 1})) == {}
 
-    def test_fallback_signers(self, serializer_factory, value):
+    def test_fallback_signers(self, serializer_factory, value: Any):
         serializer = serializer_factory(signer_kwargs={"digest_method": hashlib.sha256})
         signed = serializer.dumps(value)
 
@@ -145,8 +165,8 @@ class TestSerializer:
 
         assert fallback_serializer.loads(signed) == value
 
-    def test_iter_unsigners(self, serializer, serializer_factory):
-        class Signer256(serializer.signer):
+    def test_iter_unsigners(self, serializer: Serializer, serializer_factory):
+        class Signer256(serializer.signer):  # type: ignore
             default_digest_method = hashlib.sha256
 
         serializer = serializer_factory(
diff --git a/tests/test_itsdangerous/test_signer.py b/tests/test_itsdangerous/test_signer.py
index 01f14f6..1e05388 100644
--- a/tests/test_itsdangerous/test_signer.py
+++ b/tests/test_itsdangerous/test_signer.py
@@ -106,4 +106,4 @@ def test_abstract_algorithm():
     alg = SigningAlgorithm()
 
     with pytest.raises(NotImplementedError):
-        alg.get_signature("a", "b")
+        alg.get_signature(b"a", b"b")
diff --git a/tests/test_itsdangerous/test_timed.py b/tests/test_itsdangerous/test_timed.py
index 82b4253..5504300 100644
--- a/tests/test_itsdangerous/test_timed.py
+++ b/tests/test_itsdangerous/test_timed.py
@@ -6,9 +6,9 @@ from functools import partial
 import pytest
 from freezegun import freeze_time
 
-from itsdangerous import Signer
 from itsdangerous.exc import BadTimeSignature
 from itsdangerous.exc import SignatureExpired
+from itsdangerous.signer import Signer
 from itsdangerous.timed import TimedSerializer
 from itsdangerous.timed import TimestampSigner
 from test_itsdangerous.test_serializer import TestSerializer
diff --git a/tests/test_itsdangerous/test_url_safe.py b/tests/test_itsdangerous/test_url_safe.py
index 09a7e7c..37e4812 100644
--- a/tests/test_itsdangerous/test_url_safe.py
+++ b/tests/test_itsdangerous/test_url_safe.py
@@ -2,8 +2,8 @@ from functools import partial
 
 import pytest
 
-from itsdangerous import URLSafeSerializer
-from itsdangerous import URLSafeTimedSerializer
+from itsdangerous.url_safe import URLSafeSerializer
+from itsdangerous.url_safe import URLSafeTimedSerializer
 from test_itsdangerous.test_serializer import TestSerializer
 from test_itsdangerous.test_timed import TestTimedSerializer