rename isessionservice to isessionstrategy

Author: eadwinCode

ellar/auth/session/__init__.py

@@ -1,18 +1,18 @@
 import typing as t
 
 from .cookie_dict import SessionCookieObject
-from .interface import ISessionService
+from .interface import ISessionStrategy
 from .options import SessionCookieOption
 
 __all__ = [
     "SessionCookieObject",
     "SessionCookieOption",
-    "ISessionService",
+    "ISessionStrategy",
     "SessionServiceNullStrategy",
 ]
 
 
-class SessionServiceNullStrategy(ISessionService):
+class SessionServiceNullStrategy(ISessionStrategy):
     """
     A Null implementation ISessionService. This is used as a placeholder for ISSessionService when there is no
     ISSessionService implementation registered.

ellar/auth/session/interface.py

@@ -5,7 +5,7 @@
 from .options import SessionCookieOption
 
 
-class ISessionService(ABC):
+class ISessionStrategy(ABC):
     @property
     @abstractmethod
     def session_cookie_options(self) -> SessionCookieOption:

ellar/auth/session/strategy.py

@@ -16,12 +16,12 @@
 from ellar.di import injectable
 
 from .cookie_dict import SessionCookieObject
-from .interface import ISessionService
+from .interface import ISessionStrategy
 from .options import SessionCookieOption
 
 
 @injectable
-class SessionClientStrategy(ISessionService):
+class SessionClientStrategy(ISessionStrategy):
     def __init__(self, config: Config) -> None:
         self._signer = itsdangerous.TimestampSigner(str(config.SECRET_KEY))
         self.config = config

ellar/core/core_services.py

@@ -1,7 +1,7 @@
 import typing as t
 
 from ellar.auth import AppIdentitySchemes, IIdentitySchemes
-from ellar.auth.session import ISessionService, SessionServiceNullStrategy
+from ellar.auth.session import ISessionStrategy, SessionServiceNullStrategy
 from ellar.common import (
     IExceptionMiddlewareService,
     IExecutionContextFactory,
@@ -58,5 +58,5 @@ def register_core_services(self) -> None:
         self.injector.container.register_singleton(IGuardsConsumer, GuardConsumer)
         self.injector.container.register_singleton(IIdentitySchemes, AppIdentitySchemes)
         self.injector.container.register_singleton(
-            ISessionService, SessionServiceNullStrategy
+            ISessionStrategy, SessionServiceNullStrategy
         )

ellar/core/middleware/sessions.py

@@ -2,18 +2,18 @@
 from starlette.requests import HTTPConnection
 from starlette.types import ASGIApp, Message, Receive, Scope, Send
 
-from ellar.auth.session import ISessionService, SessionServiceNullStrategy
+from ellar.auth.session import ISessionStrategy, SessionServiceNullStrategy
 from ellar.core.conf import Config
 
 
 class SessionMiddleware:
     def __init__(
-        self, app: ASGIApp, session_service: ISessionService, config: Config
+        self, app: ASGIApp, session_strategy: ISessionStrategy, config: Config
     ) -> None:
         config.setdefault("SESSION_DISABLED", False)
         self.app = app
-        self._session_service = session_service
-        self._is_active = not isinstance(session_service, SessionServiceNullStrategy)
+        self._session_strategy = session_strategy
+        self._is_active = not isinstance(session_strategy, SessionServiceNullStrategy)
         self._is_disabled = config.SESSION_DISABLED
 
     async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
@@ -26,13 +26,13 @@ async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
             return
 
         connection = HTTPConnection(scope)
-        session_service_config = self._session_service.session_cookie_options
+        session_service_config = self._session_strategy.session_cookie_options
 
         if session_service_config.NAME in connection.cookies:
             data = connection.cookies[session_service_config.NAME]
-            scope["session"] = self._session_service.deserialize_session(data)
+            scope["session"] = self._session_strategy.deserialize_session(data)
         else:
-            scope["session"] = self._session_service.deserialize_session(None)
+            scope["session"] = self._session_strategy.deserialize_session(None)
 
         async def _send_wrapper(message: Message) -> None:
             if message["type"] == "http.response.start":
@@ -41,13 +41,13 @@ async def _send_wrapper(message: Message) -> None:
                     headers = MutableHeaders(scope=message)
                     headers.append(
                         "Set-Cookie",
-                        self._session_service.serialize_session(scope["session"]),
+                        self._session_strategy.serialize_session(scope["session"]),
                     )
                 else:
                     # The session has been cleared.
                     headers = MutableHeaders(scope=message)
                     headers.append(
-                        "Set-Cookie", self._session_service.serialize_session("null")
+                        "Set-Cookie", self._session_strategy.serialize_session("null")
                     )
 
             await send(message)

tests/test_auth/test_session/test_session_basic.py

@@ -1,6 +1,6 @@
 import pytest
 
-from ellar.auth.session import ISessionService, SessionServiceNullStrategy
+from ellar.auth.session import ISessionStrategy, SessionServiceNullStrategy
 from ellar.auth.session.strategy import SessionClientStrategy
 from ellar.common import Req, get
 from ellar.testing import Test
@@ -16,7 +16,7 @@ def homepage(req=Req()):
 
 
 def test_session_object_raise_an_exception():
-    session_service = tm.get(ISessionService)
+    session_service = tm.get(ISessionStrategy)
     assert isinstance(session_service, SessionServiceNullStrategy)
 
     with pytest.raises(AssertionError):
@@ -26,9 +26,9 @@ def test_session_object_raise_an_exception():
 
 def test_session_object_raise_an_exception_case_2():
     tm_case_2 = Test.create_test_module(config_module=dict(SESSION_DISABLED=True))
-    tm_case_2.override_provider(ISessionService, use_class=SessionClientStrategy)
+    tm_case_2.override_provider(ISessionStrategy, use_class=SessionClientStrategy)
     tm_case_2.create_application().router.append(homepage)
-    session_service = tm_case_2.get(ISessionService)
+    session_service = tm_case_2.get(ISessionStrategy)
     assert isinstance(session_service, SessionClientStrategy)
 
     with pytest.raises(AssertionError):

tests/test_auth/test_session/test_session_client_strategy.py

@@ -2,7 +2,7 @@
 
 from starlette.routing import Mount
 
-from ellar.auth.session import ISessionService
+from ellar.auth.session import ISessionStrategy
 from ellar.auth.session.strategy import SessionClientStrategy
 from ellar.common import Controller, delete, get, post
 from ellar.core import Request
@@ -32,7 +32,7 @@ def test_session():
     test_module = Test.create_test_module(
         controllers=[SessionSampleController], config_module=dict(SECRET_KEY="secret")
     )
-    test_module.override_provider(ISessionService, use_class=SessionClientStrategy)
+    test_module.override_provider(ISessionStrategy, use_class=SessionClientStrategy)
     client = test_module.get_test_client()
 
     response = client.get("/")
@@ -62,7 +62,7 @@ def test_session_expires():
         controllers=[SessionSampleController],
         config_module=dict(SECRET_KEY="secret", SESSION_COOKIE_MAX_AGE=-1),
     )
-    test_module.override_provider(ISessionService, use_class=SessionClientStrategy)
+    test_module.override_provider(ISessionStrategy, use_class=SessionClientStrategy)
     client = test_module.get_test_client()
 
     response = client.post("/", json={"some": "data"})
@@ -84,7 +84,7 @@ def test_secure_session():
         controllers=[SessionSampleController],
         config_module=dict(SECRET_KEY="secret", SESSION_COOKIE_SECURE=True),
     )
-    test_module.override_provider(ISessionService, use_class=SessionClientStrategy)
+    test_module.override_provider(ISessionStrategy, use_class=SessionClientStrategy)
     secure_client = test_module.get_test_client(base_url="https://testserver")
     unsecure_client = test_module.get_test_client(base_url="http://testserver")
 
@@ -124,7 +124,7 @@ def test_session_cookie_sub_path():
         ],
         config_module=dict(SECRET_KEY="secret", SESSION_COOKIE_PATH="/second_app"),
     )
-    test_module.override_provider(ISessionService, use_class=SessionClientStrategy)
+    test_module.override_provider(ISessionStrategy, use_class=SessionClientStrategy)
 
     client_second_app = test_module.get_test_client(
         base_url="http://testserver/second_app"
@@ -156,7 +156,7 @@ def test_invalid_session_cookie():
     test_module = Test.create_test_module(
         controllers=[SessionSampleController], config_module=dict(SECRET_KEY="secret")
     )
-    test_module.override_provider(ISessionService, use_class=SessionClientStrategy)
+    test_module.override_provider(ISessionStrategy, use_class=SessionClientStrategy)
     client = test_module.get_test_client()
 
     response = client.post("/", json={"some": "data"})
@@ -173,7 +173,7 @@ def test_session_cookie():
         controllers=[SessionSampleController],
         config_module=dict(SECRET_KEY="secret", SESSION_COOKIE_MAX_AGE=None),
     )
-    test_module.override_provider(ISessionService, use_class=SessionClientStrategy)
+    test_module.override_provider(ISessionStrategy, use_class=SessionClientStrategy)
     client = test_module.get_test_client()
 
     response = client.post("/", json={"some": "data"})

tests/test_routing/test_route_endpoint_params.py

@@ -5,7 +5,7 @@
 from starlette.responses import Response as StarletteResponse
 from starlette.websockets import WebSocket as StarletteWebSocket
 
-from ellar.auth.session import ISessionService
+from ellar.auth.session import ISessionStrategy
 from ellar.auth.session.strategy import SessionClientStrategy
 from ellar.common import (
     Context,
@@ -80,7 +80,7 @@ async def get_websockets(websocket: StarletteWebSocket, ws=Ws()):
     config_module=dict(
         SECRET_KEY=SECRET_KEY,
     ),
-).override_provider(ISessionService, use_class=SessionClientStrategy)
+).override_provider(ISessionStrategy, use_class=SessionClientStrategy)
 client = tm.get_test_client()