update tests

Makefile

@@ -120,4 +120,4 @@ endif
 
 .PHONY: test
 test:  ## Run the test suite and report coverage.
-	@poetry run pytest
+	@poetry run pytest --cov starlette_session

config/coverage.ini

@@ -0,0 +1,21 @@
+
+[coverage:paths]
+source =
+  starlette_session
+  */site-packages/starlette_session
+omit = 
+  starlette_session/interfaces.py
+
+[coverage:run]
+branch = true
+source =
+  starlette_session
+  tests
+parallel = true
+
+[coverage:report]
+precision = 2
+omit =
+  starlette_session/interfaces.py
+  tests/*
+

starlette_session/backends.py

@@ -12,17 +12,17 @@
 try:
     from aioredis import Redis as AioRedis
 except ImportError:
-    AioRedis = None
+    AioRedis = None  # pragma: no cover
 
 try:
     from pymemcache.client.base import Client as Memcache
 except ImportError:
-    Memcache = None
+    Memcache = None  # pragma: no cover
 
 try:
     from aiomcache import Client as AioMemcache
 except ImportError:
-    AioMemcache = None
+    AioMemcache = None  # pragma: no cover
 
 
 from starlette_session.interfaces import ISessionBackend
@@ -73,20 +73,20 @@ async def delete(self, key: str) -> Any:
         return self.redis.delete(key)
 
 
-class AioRedisSessionBackend(ISessionBackend):
-    def __init__(self, redis: AioRedis):
+class AioRedisSessionBackend(ISessionBackend): 
+    def __init__(self, redis: AioRedis):  # pragma: no cover
         self.redis = redis
 
-    async def get(self, key: str) -> Optional[dict]:
+    async def get(self, key: str) -> Optional[dict]:  # pragma: no cover
         value = await self.redis.get(key)
         return _loads(value) if value else None
 
     async def set(
         self, key: str, value: dict, exp: Optional[int] = None
-    ) -> Optional[str]:
+    ) -> Optional[str]:  # pragma: no cover
         return await self.redis.set(key, _dumps(value), expire=exp)
 
-    async def delete(self, key: str) -> Any:
+    async def delete(self, key: str) -> Any:  # pragma: no cover
         return await self.redis.delete(key)
 
 
@@ -109,17 +109,17 @@ async def delete(self, key: str) -> Any:
 
 
 class AioMemcacheSessionBackend(ISessionBackend):
-    def __init__(self, memcache: AioMemcache):
+    def __init__(self, memcache: AioMemcache):  # pragma: no cover
         self.memcache = memcache
 
-    async def get(self, key: str) -> Optional[dict]:
+    async def get(self, key: str) -> Optional[dict]:  # pragma: no cover
         value = await self.memcache.get(key.encode())
         return _loads(value) if value else None
 
     async def set(
         self, key: str, value: dict, exp: Optional[int] = None
-    ) -> Optional[str]:
+    ) -> Optional[str]:  # pragma: no cover
         return await self.memcache.set(key.encode(), _dumps(value), exptime=exp)
 
-    async def delete(self, key: str) -> Any:
+    async def delete(self, key: str) -> Any:  # pragma: no cover
         return await self.memcache.delete(key.encode())

starlette_session/interfaces.py

@@ -5,12 +5,12 @@
 class ISessionBackend(ABC):
     @abstractmethod
     async def get(self, key: str) -> Optional[dict]:
-        raise NotImplementedError()
+        raise NotImplementedError()  # pragma: no cover
 
     @abstractmethod
     async def set(self, key: str, value: dict, exp: Optional[int]) -> Optional[str]:
-        raise NotImplementedError()
+        raise NotImplementedError()  # pragma: no cover
 
     @abstractmethod
     async def delete(self, key: str) -> Any:
-        raise NotImplementedError()
+        raise NotImplementedError()  # pragma: no cover

tests/test_backends.py

@@ -11,7 +11,7 @@
 from starlette.testclient import TestClient
 
 from starlette_session import SessionMiddleware
-from starlette_session.backends import BackendType
+from starlette_session.backends import BackendType, MemcacheJSONSerde
 
 
 def view_session(request: Request) -> JSONResponse:
@@ -47,6 +47,20 @@ def redis() -> fakeredis.FakeStrictRedis:
 def memcache():
     return MockMemcacheClient()
 
+def test_MemcacheJSONSerde():
+    serde = MemcacheJSONSerde()
+
+    assert serde.serialize("key", "test") == ("test", 1)
+
+    assert serde.serialize("key", {"key1": "test"}) == ('{"key1": "test"}', 2)
+
+    assert serde.deserialize("key", "value", 1) == "value"
+
+    assert serde.deserialize("key", '{"key1": "test"}', 2) == {"key1": "test"}
+
+    with pytest.raises(Exception):
+        serde.deserialize("key", '{"key1": "test"}', -1)
+
 
 def test_without_backend(app):