renamed BasePolicyHandler to Policy

Author: eadwinCode

ellar/auth/__init__.py

@@ -3,10 +3,10 @@
 from .identity import UserIdentity
 from .interceptor import AuthorizationInterceptor
 from .policy import (
-    BasePolicyHandler,
-    BasePolicyHandlerWithRequirement,
-    RequiredClaimsPolicy,
-    RequiredRolePolicy,
+    ClaimsPolicy,
+    Policy,
+    PolicyWithRequirement,
+    RolePolicy,
 )
 from .services import AppIdentitySchemes, IdentityAuthenticationService
 
@@ -16,11 +16,11 @@
     "Authorize",
     "BaseAuthenticationHandler",
     "CheckPolicies",
-    "BasePolicyHandler",
-    "BasePolicyHandlerWithRequirement",
+    "Policy",
+    "PolicyWithRequirement",
     "UserIdentity",
-    "RequiredClaimsPolicy",
-    "RequiredRolePolicy",
+    "ClaimsPolicy",
+    "RolePolicy",
     "AppIdentitySchemes",
     "IdentityAuthenticationService",
     "AuthenticationRequired",

ellar/auth/interceptor.py

@@ -6,7 +6,7 @@
 from starlette import status
 
 from .constants import POLICY_KEYS
-from .policy import BasePolicyHandler, PolicyType
+from .policy import Policy, PolicyType
 
 
 @injectable
@@ -26,7 +26,7 @@ def get_route_handler_policy(
 
     def _get_policy_instance(
         self, context: IExecutionContext, policy: t.Union[t.Type, t.Any, str]
-    ) -> t.Union[BasePolicyHandler, t.Any]:
+    ) -> t.Union[Policy, t.Any]:
         if isinstance(policy, type):
             return context.get_service_provider().get(policy)
         return policy

ellar/auth/policy/__init__.py

@@ -1,16 +1,16 @@
 from .base import (
-    BasePolicyHandler,
-    BasePolicyHandlerWithRequirement,
     DefaultRequirementType,
+    Policy,
     PolicyType,
+    PolicyWithRequirement,
 )
-from .common import RequiredClaimsPolicy, RequiredRolePolicy
+from .common import ClaimsPolicy, RolePolicy
 
 __all__ = [
-    "BasePolicyHandler",
-    "BasePolicyHandlerWithRequirement",
+    "Policy",
+    "PolicyWithRequirement",
     "DefaultRequirementType",
     "PolicyType",
-    "RequiredClaimsPolicy",
-    "RequiredRolePolicy",
+    "ClaimsPolicy",
+    "RolePolicy",
 ]

ellar/auth/policy/base.py

@@ -9,7 +9,7 @@ class DefaultRequirementType(AttributeDict):
     """
     Stores Policy Requirement Arguments in `arg_[n]` value
     example:
-        class MyPolicyHandler(BasePolicyHandlerWithRequirement):
+        class MyPolicyHandler(PolicyWithRequirement):
             ...
 
         policy = MyPolicyHandler['req1', 'req2', 'req2']
@@ -26,40 +26,40 @@ def __init__(self, *args: t.Any) -> None:
 class _PolicyOperandMixin:
     @t.no_type_check
     def __and__(
-        cls: t.Union["BasePolicyHandler", t.Type["BasePolicyHandler"]],
-        other: t.Union["BasePolicyHandler", t.Type["BasePolicyHandler"]],
-    ) -> "BasePolicyHandler":
+        cls: t.Union["Policy", t.Type["Policy"]],
+        other: t.Union["Policy", t.Type["Policy"]],
+    ) -> "Policy":
         return _ANDPolicy(cls, other)
 
     @t.no_type_check
     def __or__(
-        cls: t.Union["BasePolicyHandler", t.Type["BasePolicyHandler"]],
-        other: t.Union["BasePolicyHandler", t.Type["BasePolicyHandler"]],
-    ) -> "BasePolicyHandler":
+        cls: t.Union["Policy", t.Type["Policy"]],
+        other: t.Union["Policy", t.Type["Policy"]],
+    ) -> "Policy":
         return _ORPolicy(cls, other)
 
     @t.no_type_check
     def __invert__(
-        cls: t.Union["BasePolicyHandler", t.Type["BasePolicyHandler"]],
-    ) -> "BasePolicyHandler":
+        cls: t.Union["Policy", t.Type["Policy"]],
+    ) -> "Policy":
         return _NOTPolicy(cls)
 
 
-class BasePolicyHandlerMetaclass(_PolicyOperandMixin, ABCMeta):
+class PolicyMetaclass(_PolicyOperandMixin, ABCMeta):
     pass
 
 
-class BasePolicyHandler(ABC, _PolicyOperandMixin, metaclass=BasePolicyHandlerMetaclass):
+class Policy(ABC, _PolicyOperandMixin, metaclass=PolicyMetaclass):
     @abstractmethod
     async def handle(self, context: IExecutionContext) -> bool:
         """Run Policy Actions and return true or false"""
 
 
-class BasePolicyHandlerWithRequirement(
-    BasePolicyHandler,
+class PolicyWithRequirement(
+    Policy,
     ABC,
 ):
-    __requirements__: t.Dict[int, "BasePolicyHandler"] = {}
+    __requirements__: t.Dict[int, "Policy"] = {}
 
     requirement_type: t.Type = DefaultRequirementType
 
@@ -68,7 +68,7 @@ class BasePolicyHandlerWithRequirement(
     async def handle(self, context: IExecutionContext, requirement: t.Any) -> bool:
         """Handle Policy Action"""
 
-    def __class_getitem__(cls, parameters: t.Any) -> "BasePolicyHandler":
+    def __class_getitem__(cls, parameters: t.Any) -> "Policy":
         _parameters = parameters if isinstance(parameters, tuple) else (parameters,)
         hash_id = hash(_parameters)
         if hash_id not in cls.__requirements__:
@@ -79,24 +79,24 @@ def __class_getitem__(cls, parameters: t.Any) -> "BasePolicyHandler":
 
 
 PolicyType = t.Union[
-    BasePolicyHandler,
-    t.Type[BasePolicyHandler],
-    BasePolicyHandlerWithRequirement,
-    t.Type[BasePolicyHandlerWithRequirement],
+    Policy,
+    t.Type[Policy],
+    PolicyWithRequirement,
+    t.Type[PolicyWithRequirement],
 ]
 
 
 class _OperandResolversMixin:
     def _get_policy_object(
         self, context: IExecutionContext, policy: PolicyType
-    ) -> t.Union[BasePolicyHandler, BasePolicyHandlerWithRequirement]:
+    ) -> t.Union[Policy, PolicyWithRequirement]:
         if isinstance(policy, type):
             # resolve instance from EllarInjector, we assume the policy hand been decorated with @injector decorator.
             return context.get_service_provider().get(policy)  # type: ignore[no-any-return]
         return policy
 
 
-class _ORPolicy(BasePolicyHandler, _OperandResolversMixin):
+class _ORPolicy(Policy, _OperandResolversMixin):
     def __init__(self, policy_1: PolicyType, policy_2: PolicyType) -> None:
         self._policy_1 = policy_1
         self._policy_2 = policy_2
@@ -111,7 +111,7 @@ async def handle(self, context: IExecutionContext) -> bool:
         return _policy_1_result or _policy_2_result
 
 
-class _NOTPolicy(BasePolicyHandler, _OperandResolversMixin):
+class _NOTPolicy(Policy, _OperandResolversMixin):
     def __init__(self, policy_1: PolicyType) -> None:
         self._policy_1 = policy_1
 
@@ -134,7 +134,7 @@ async def handle(self, context: IExecutionContext) -> bool:
         return _policy_1_result and _policy_2_result
 
 
-class _PolicyHandlerWithRequirement(BasePolicyHandler, _OperandResolversMixin):
+class _PolicyHandlerWithRequirement(Policy, _OperandResolversMixin):
     def __init__(self, policy_1: PolicyType, requirement: t.Any) -> None:
         self._policy_1 = policy_1
         self.requirement = requirement

ellar/auth/policy/common.py

@@ -2,10 +2,10 @@
 
 from ellar.common import IExecutionContext
 
-from .base import BasePolicyHandler
+from .base import Policy
 
 
-class RequiredRolePolicy(BasePolicyHandler):
+class RolePolicy(Policy):
     def __init__(self, *role: str):
         self.roles = list(role)
 
@@ -14,7 +14,7 @@ async def handle(self, context: IExecutionContext) -> bool:
         return all(role in user_roles for role in self.roles)
 
 
-class RequiredClaimsPolicy(BasePolicyHandler):
+class ClaimsPolicy(Policy):
     def __init__(self, claim_type: str, *claim_value: t.Any) -> None:
         self.claim_type = claim_type
         self.claim_values = list(claim_value)

tests/test_auth/app/controllers.py

@@ -1,5 +1,5 @@
 from ellar.auth import AuthenticationRequired, Authorize, CheckPolicies
-from ellar.auth.policy import RequiredClaimsPolicy, RequiredRolePolicy
+from ellar.auth.policy import ClaimsPolicy, RolePolicy
 from ellar.common import Controller, get
 
 from .policies import AdultOnly, AtLeast21
@@ -20,7 +20,7 @@ async def fast_x(self):
 class ArticleController:
     @get("/create")
     @AuthenticationRequired
-    @CheckPolicies(RequiredClaimsPolicy("article", "create", "publish"))
+    @CheckPolicies(ClaimsPolicy("article", "create", "publish"))
     async def create_and_publish(self):
         return "fast and furious 10 Article"
 
@@ -30,13 +30,13 @@ async def get_articles(self):
 
     @get("/admin-only")
     @AuthenticationRequired("SimpleHeaderAuthHandler")
-    @CheckPolicies(RequiredRolePolicy("admin"))
+    @CheckPolicies(RolePolicy("admin"))
     async def admin_only(self):
         return "List of articles"
 
     @get("/staff-only")
     @AuthenticationRequired("SimpleHeaderAuthHandler")
-    @CheckPolicies(RequiredRolePolicy("staff"))
+    @CheckPolicies(RolePolicy("staff"))
     async def staff_only(self):
         return "List of articles"
 

tests/test_auth/app/policies.py

@@ -1,19 +1,19 @@
 import typing as t
 
-from ellar.auth import BasePolicyHandler, BasePolicyHandlerWithRequirement
+from ellar.auth import Policy, PolicyWithRequirement
 from ellar.common import IExecutionContext
 from ellar.di import injectable
 
 
 @injectable
-class AtLeast21(BasePolicyHandlerWithRequirement):
+class AtLeast21(PolicyWithRequirement):
     async def handle(self, context: IExecutionContext, requirement: t.Any) -> bool:
         for _k, v in requirement.items():
             assert v in context.user.requirements
         return int(context.user.get("age")) >= 21
 
 
 @injectable
-class AdultOnly(BasePolicyHandler):
+class AdultOnly(Policy):
     async def handle(self, context: IExecutionContext) -> bool:
         return int(context.user.get("age")) >= 18

tests/test_auth/test_policy_logic_gates.py

@@ -1,7 +1,7 @@
 from unittest.mock import Mock
 
 import pytest
-from ellar.auth import BasePolicyHandler, BasePolicyHandlerWithRequirement
+from ellar.auth import Policy, PolicyWithRequirement
 from ellar.common import IExecutionContext
 from ellar.di import EllarInjector
 
@@ -16,7 +16,7 @@ def __init__(self, a: str, b: str):
         self.b = b
 
 
-class EllarPolicy(BasePolicyHandlerWithRequirement):
+class EllarPolicy(PolicyWithRequirement):
     requirement_type = MyRequirement
 
     async def handle(
@@ -25,19 +25,19 @@ async def handle(
         return requirement.a == "ellar" and requirement.b == "policy"
 
 
-class AnyPolicy(BasePolicyHandlerWithRequirement):
+class AnyPolicy(PolicyWithRequirement):
     async def handle(self, context: IExecutionContext, requirement=None) -> bool:
         if requirement:
             return requirement.arg_1 == requirement.arg_2
         return requirement is None
 
 
-class TruePolicyHandler(BasePolicyHandler):
+class TruePolicyHandler(Policy):
     async def handle(self, context: IExecutionContext) -> bool:
         return True
 
 
-class FalsePolicyHandler(BasePolicyHandler):
+class FalsePolicyHandler(Policy):
     async def handle(self, context: IExecutionContext) -> bool:
         return False
 

tests/test_auth/test_require_claim_policy.py

@@ -1,6 +1,6 @@
 from unittest.mock import Mock
 
-from ellar.auth import RequiredClaimsPolicy, UserIdentity
+from ellar.auth import ClaimsPolicy, UserIdentity
 
 
 def mock_execution_context(**kwargs):
@@ -12,7 +12,7 @@ def mock_execution_context(**kwargs):
 
 async def test_require_claim_raises_an_exception(anyio_backend):
     context = mock_execution_context()
-    claim = RequiredClaimsPolicy("article", "create", "publish")
+    claim = ClaimsPolicy("article", "create", "publish")
 
     assert await claim.handle(context) is False