Add tests for Base32 decode attempts with non-ascii chars.

tests/conftest.py

@@ -13,6 +13,9 @@
 from ulid import base32
 
 
+NON_ASCII_ALPHABET = ''.join(chr(d) for d in range(128, 256))
+
+
 @pytest.fixture(scope='session')
 def valid_bytes_48_before():
     """
@@ -179,6 +182,15 @@ def invalid_str_10_16_26(request):
     return random_str(request.param, not_in=[10, 16, 26])
 
 
+@pytest.fixture(scope='function', params=range(0, 32))
+def invalid_str_encoding(request):
+    """
+    Fixture that yields :class:`~str` instances that are between 0 and 32 characters
+    that uses non-ascii characters.
+    """
+    return random_str(request.param, alphabet=NON_ASCII_ALPHABET)
+
+
 def random_bytes(num_bytes, not_in=(-1,)):
     """
     Helper function that returns a number of random bytes, optionally excluding those of a specific length.
@@ -187,13 +199,13 @@ def random_bytes(num_bytes, not_in=(-1,)):
     return os.urandom(num_bytes)
 
 
-def random_str(num_chars, not_in=(-1,)):
+def random_str(num_chars, alphabet=base32.ENCODING, not_in=(-1,)):
     """
     Helper function that returns a string with the specified number of random characters, optionally
     excluding those of a specific length.
     """
     num_chars = num_chars + 1 if num_chars in not_in else num_chars
-    return ''.join(random.choice(base32.ENCODING) for _ in range(num_chars))
+    return ''.join(random.choice(alphabet) for _ in range(num_chars))
 
 
 def fixed_year_timestamp_bytes(*args, **kwargs):

tests/test_base32.py

@@ -144,6 +144,15 @@ def test_decode_raises_on_str_length_mismatch(invalid_str_10_16_26):
         base32.decode(invalid_str_10_16_26)
 
 
+def test_decode_raises_on_non_ascii_str(invalid_str_encoding):
+    """
+    Assert that :func:`~ulid.base32.decode` raises a :class:`~ValueError` when given a :class:`~str`
+    instance that contains non-ascii characters.
+    """
+    with pytest.raises(ValueError):
+        base32.decode(invalid_str_encoding)
+
+
 def test_decode_ulid_returns_16_bytes(valid_str_26):
     """
     Assert that :func:`~ulid.base32.decode_ulid` decodes a valid 26 character string  into a :class:`~bytes`
@@ -163,6 +172,15 @@ def test_decode_ulid_raises_on_str_length_mismatch(invalid_str_26):
         base32.decode_ulid(invalid_str_26)
 
 
+def test_decode_ulid_raises_on_non_ascii_str(invalid_str_encoding):
+    """
+    Assert that :func:`~ulid.base32.decode_ulid` raises a :class:`~ValueError` when given a :class:`~str`
+    instance that contains non-ascii characters.
+    """
+    with pytest.raises(ValueError):
+        base32.decode_ulid(invalid_str_encoding)
+
+
 def test_decode_timestamp_returns_6_bytes(valid_str_10):
     """
     Assert that :func:`~ulid.base32.decode_timestamp` decodes a valid 10 character string  into a :class:`~bytes`
@@ -182,6 +200,15 @@ def test_decode_timestamp_raises_on_str_length_mismatch(invalid_str_10):
         base32.decode_timestamp(invalid_str_10)
 
 
+def test_decode_timestamp_raises_on_non_ascii_str(invalid_str_encoding):
+    """
+    Assert that :func:`~ulid.base32.decode_timestamp` raises a :class:`~ValueError` when given a :class:`~str`
+    instance that contains non-ascii characters.
+    """
+    with pytest.raises(ValueError):
+        base32.decode_timestamp(invalid_str_encoding)
+
+
 def test_decode_randomness_returns_10_bytes(valid_str_16):
     """
     Assert that :func:`~ulid.base32.decode_randomness` decodes a valid 16 character string  into a :class:`~bytes`
@@ -199,3 +226,12 @@ def test_decode_randomness_raises_on_str_length_mismatch(invalid_str_16):
     """
     with pytest.raises(ValueError):
         base32.decode_randomness(invalid_str_16)
+
+
+def test_decode_randomness_raises_on_non_ascii_str(invalid_str_encoding):
+    """
+    Assert that :func:`~ulid.base32.decode_randomness` raises a :class:`~ValueError` when given a :class:`~str`
+    instance that contains non-ascii characters.
+    """
+    with pytest.raises(ValueError):
+        base32.decode_randomness(invalid_str_encoding)