Add serialize_str & unserialize_str

Author: homm

Makefile

@@ -4,4 +4,4 @@ lint:
 	pyright .
 
 test:
-	pytest -v --cov=encryptedcookie --cov-report=html
+	pytest -v --cov=encryptedcookie --cov-report=html --cov-report=term

encryptedcookie/__init__.py

@@ -65,6 +65,15 @@ def serialize(
 
         return string
 
+    def serialize_str(
+            self, data: dict, expires: float | int | timedelta | None = None
+    ) -> str:
+        string = self.serialize(data, expires)
+        if self.quote_base64:
+            return string.decode('ascii')
+        else:
+            return string.hex()
+
     @classmethod
     def loads(cls, data: bytes) -> dict:
         return json.loads(data.decode())
@@ -90,7 +99,7 @@ def unserialize(self, string: bytes) -> dict:
         if self.quote_base64:
             try:
                 string = base64.b64decode(string)
-            except Exception:
+            except ValueError:
                 pass
 
         payload = self.decrypt(string)
@@ -109,6 +118,16 @@ def unserialize(self, string: bytes) -> dict:
 
         return data
 
+    def unserialize_str(self, string: str) -> dict:
+        if self.quote_base64:
+            data = string.encode()
+        else:
+            try:
+                data = bytes.fromhex(string)
+            except ValueError:
+                data = string.encode()
+        return self.unserialize(data)
+
 
 class SecureEncryptedCookie(EncryptedCookie):
     def encrypt(self, data: bytes) -> bytes:

tests.py

@@ -53,6 +53,16 @@ def test_serialize_unserialize(self):
             r = cookie.unserialize(r)
             assert r == case
 
+    def test_serialize_str_unserialize_str(self):
+        for Cookie in [self.Cookie, self.RawCookie]:
+            cookie = Cookie(b'my little key')
+            for case in [{'a': 'b'}, {'a': 'próba'}, {'próba': '123'}]:
+                r = cookie.serialize_str(case)
+                assert isinstance(r, str)
+
+                r = cookie.unserialize_str(r)
+                assert r == case
+
     def test_unserialize_binary(self):
         """
         Test unserialize compatibility with existing binary data.
@@ -104,6 +114,31 @@ def test_fail_when_corrupted(self):
         r = cookie.unserialize(r[:20] + r[21:])
         assert not r
 
+    def test_fail_incorrect_str(self):
+        cookie = self.Cookie(b'my little key')
+        raw = self.RawCookie(b'my little key').serialize({'a': 'próba'})
+
+        # Send somthing which can't be base64 decoded
+        r = cookie.unserialize_str(raw.hex())
+        assert r == {}
+
+        # Send somthing not ascii at all
+        r = cookie.unserialize_str(raw.decode('latin-1'))
+        assert r == {}
+
+    def test_fail_incorrect_raw_str(self):
+        b64 = self.Cookie(b'my little key').serialize({'a': 'próba'})
+        raw_cookie = self.RawCookie(b'my little key')
+
+        # Send somthing which can't be hex decoded
+        r = raw_cookie.unserialize_str(b64.decode())
+        assert r == {}
+
+        # Send somthing not ascii at all
+        raw = raw_cookie.serialize({'a': 'próba'})
+        r = raw_cookie.unserialize_str(raw.decode('latin-1'))
+        assert r == {}
+
     def test_compression_and_decompression(self):
         key = b'my little key'
         case = {'a': 'próba'}