Buckets:
AnonymousSpottedToad/candidate_bucket / codebase /python /DeepselSystems_deepsel /tests /test_user_mixin.py
| """Tests for role/permission resolution in deepsel.orm.user_mixin.UserMixin. | |
| Covers: | |
| - get_user_permissions: JSON parsing, multi-role union, implied-role | |
| contribution (single + multi-level), cycle safety, empty/None permissions. | |
| - get_user_roles: transitive role set, cycle safety. | |
| - is_admin: direct and implied admin roles. | |
| - get_user_has_roles: classmethod DB query for users holding a role directly | |
| or via an implied-role mapping. | |
| """ | |
| import json | |
| # NOTE: import deepsel.utils first to avoid a circular-import error during | |
| # isolated collection (known package import-order quirk). | |
| from deepsel.utils.models_pool import models_pool | |
| from sqlalchemy import ( | |
| Column, | |
| Integer, | |
| String, | |
| ForeignKey, | |
| Table, | |
| create_engine, | |
| ) | |
| from sqlalchemy.orm import Session, declarative_base, relationship | |
| from deepsel.orm.mixin import ORMBaseMixin | |
| from deepsel.orm.user_mixin import UserMixin | |
| # --------------------------------------------------------------------------- | |
| # Test models | |
| # --------------------------------------------------------------------------- | |
| Base = declarative_base() | |
| # Self-referential M2M association on Role for implied roles. | |
| # Columns named to match get_user_has_roles: role_id, implied_role_id. | |
| implied_role_table = Table( | |
| "implied_role", | |
| Base.metadata, | |
| Column("role_id", Integer, ForeignKey("role.id"), primary_key=True), | |
| Column("implied_role_id", Integer, ForeignKey("role.id"), primary_key=True), | |
| ) | |
| # User <-> Role association. Columns named user_id, role_id to match the | |
| # UserRoleModel query in get_user_has_roles. | |
| user_role_table = Table( | |
| "user_role", | |
| Base.metadata, | |
| Column("user_id", Integer, ForeignKey("user.id"), primary_key=True), | |
| Column("role_id", Integer, ForeignKey("role.id"), primary_key=True), | |
| ) | |
| class RoleModel(Base, ORMBaseMixin): | |
| __tablename__ = "role" | |
| id = Column(Integer, primary_key=True, autoincrement=True) | |
| name = Column(String(100)) | |
| permissions = Column(String, nullable=True) # JSON string list | |
| implied_roles = relationship( | |
| "RoleModel", | |
| secondary="implied_role", | |
| primaryjoin="RoleModel.id == implied_role.c.role_id", | |
| secondaryjoin="RoleModel.id == implied_role.c.implied_role_id", | |
| backref="implied_by", | |
| ) | |
| class UserModel(Base, ORMBaseMixin, UserMixin): | |
| __tablename__ = "user" | |
| id = Column(Integer, primary_key=True, autoincrement=True) | |
| name = Column(String(100)) | |
| roles = relationship("RoleModel", secondary="user_role") | |
| # A bare ORM class exposing the implied_role association table so the | |
| # get_user_has_roles query (which expects an object with row_id/implied_role_id | |
| # columns) can run db.query(models_pool["implied_role"]). | |
| class ImpliedRoleModel(Base): | |
| __table__ = implied_role_table | |
| class UserRoleModel(Base): | |
| __table__ = user_role_table | |
| # --------------------------------------------------------------------------- | |
| # Fixtures | |
| # --------------------------------------------------------------------------- | |
| import pytest # noqa: E402 | |
| def engine(pg_container): | |
| url = pg_container.get_connection_url() | |
| eng = create_engine(url) | |
| Base.metadata.create_all(eng) | |
| yield eng | |
| Base.metadata.drop_all(eng) | |
| eng.dispose() | |
| def db(engine): | |
| connection = engine.connect() | |
| transaction = connection.begin() | |
| session = Session(bind=connection) | |
| old_pool = dict(models_pool) | |
| models_pool["user"] = UserModel | |
| models_pool["role"] = RoleModel | |
| models_pool["implied_role"] = ImpliedRoleModel | |
| models_pool["user_role"] = UserRoleModel | |
| yield session | |
| session.close() | |
| transaction.rollback() | |
| connection.close() | |
| models_pool.clear() | |
| models_pool.update(old_pool) | |
| # --------------------------------------------------------------------------- | |
| # Helpers | |
| # --------------------------------------------------------------------------- | |
| def _role(db, name, permissions=None, string_id=None, implied=None): | |
| role = RoleModel( | |
| name=name, | |
| string_id=string_id, | |
| permissions=json.dumps(permissions) if permissions is not None else None, | |
| ) | |
| if implied: | |
| role.implied_roles.extend(implied) | |
| db.add(role) | |
| db.flush() | |
| return role | |
| def _user(db, name, roles=None): | |
| user = UserModel(name=name) | |
| if roles: | |
| user.roles.extend(roles) | |
| db.add(user) | |
| db.flush() | |
| return user | |
| # --------------------------------------------------------------------------- | |
| # get_user_permissions | |
| # --------------------------------------------------------------------------- | |
| class TestGetUserPermissions: | |
| def test_single_role_permissions_parsed(self, db): | |
| role = _role(db, "Reader", permissions=["item:read:*", "item:write:own"]) | |
| user = _user(db, "u1", roles=[role]) | |
| perms = user.get_user_permissions() | |
| assert set(perms) == {"item:read:*", "item:write:own"} | |
| def test_multiple_roles_union_deduped(self, db): | |
| r1 = _role(db, "R1", permissions=["item:read:*", "shared:read:*"]) | |
| r2 = _role(db, "R2", permissions=["item:write:*", "shared:read:*"]) | |
| user = _user(db, "u2", roles=[r1, r2]) | |
| perms = user.get_user_permissions() | |
| # union, de-duplicated (shared:read:* appears once) | |
| assert sorted(perms) == sorted({"item:read:*", "shared:read:*", "item:write:*"}) | |
| assert len(perms) == 3 | |
| def test_implied_role_contributes_permissions_one_level(self, db): | |
| base = _role(db, "Base", permissions=["base:read:*"]) | |
| role = _role(db, "Composite", permissions=["item:read:*"], implied=[base]) | |
| user = _user(db, "u3", roles=[role]) | |
| perms = user.get_user_permissions() | |
| assert set(perms) == {"item:read:*", "base:read:*"} | |
| def test_implied_role_multi_level_transitive(self, db): | |
| leaf = _role(db, "Leaf", permissions=["leaf:read:*"]) | |
| mid = _role(db, "Mid", permissions=["mid:read:*"], implied=[leaf]) | |
| top = _role(db, "Top", permissions=["top:read:*"], implied=[mid]) | |
| user = _user(db, "u4", roles=[top]) | |
| perms = user.get_user_permissions() | |
| assert set(perms) == {"top:read:*", "mid:read:*", "leaf:read:*"} | |
| def test_cyclic_implied_roles_terminate(self, db): | |
| a = _role(db, "A", permissions=["a:read:*"]) | |
| b = _role(db, "B", permissions=["b:read:*"]) | |
| a.implied_roles.append(b) | |
| b.implied_roles.append(a) # cycle A -> B -> A | |
| db.flush() | |
| user = _user(db, "u5", roles=[a]) | |
| perms = user.get_user_permissions() | |
| assert set(perms) == {"a:read:*", "b:read:*"} | |
| def test_role_with_none_permissions(self, db): | |
| role = _role(db, "Empty", permissions=None) | |
| user = _user(db, "u6", roles=[role]) | |
| assert user.get_user_permissions() == [] | |
| def test_role_with_empty_permissions(self, db): | |
| role = _role(db, "EmptyList", permissions=[]) | |
| user = _user(db, "u7", roles=[role]) | |
| assert user.get_user_permissions() == [] | |
| def test_none_permission_role_with_implied_still_contributes(self, db): | |
| child = _role(db, "Child", permissions=["child:read:*"]) | |
| parent = _role(db, "ParentNone", permissions=None, implied=[child]) | |
| user = _user(db, "u8", roles=[parent]) | |
| assert set(user.get_user_permissions()) == {"child:read:*"} | |
| def test_explicit_user_argument(self, db): | |
| role = _role(db, "Arg", permissions=["arg:read:*"]) | |
| target = _user(db, "target", roles=[role]) | |
| caller = _user(db, "caller", roles=[]) | |
| # Passing user explicitly resolves the target's permissions. | |
| assert set(caller.get_user_permissions(user=target)) == {"arg:read:*"} | |
| # --------------------------------------------------------------------------- | |
| # get_user_roles | |
| # --------------------------------------------------------------------------- | |
| class TestGetUserRoles: | |
| def test_transitive_role_set(self, db): | |
| leaf = _role(db, "RLeaf") | |
| mid = _role(db, "RMid", implied=[leaf]) | |
| top = _role(db, "RTop", implied=[mid]) | |
| user = _user(db, "ur1", roles=[top]) | |
| roles = user.get_user_roles() | |
| names = {r.name for r in roles} | |
| assert names == {"RTop", "RMid", "RLeaf"} | |
| def test_cycle_safe(self, db): | |
| a = _role(db, "CA") | |
| b = _role(db, "CB") | |
| a.implied_roles.append(b) | |
| b.implied_roles.append(a) | |
| db.flush() | |
| user = _user(db, "ur2", roles=[a]) | |
| roles = user.get_user_roles() | |
| names = {r.name for r in roles} | |
| assert names == {"CA", "CB"} | |
| def test_multiple_direct_roles(self, db): | |
| r1 = _role(db, "D1") | |
| r2 = _role(db, "D2") | |
| user = _user(db, "ur3", roles=[r1, r2]) | |
| roles = user.get_user_roles() | |
| assert {r.name for r in roles} == {"D1", "D2"} | |
| # --------------------------------------------------------------------------- | |
| # is_admin | |
| # --------------------------------------------------------------------------- | |
| class TestIsAdmin: | |
| def test_direct_admin_role(self, db): | |
| role = _role(db, "Admin", string_id="admin_role") | |
| user = _user(db, "adm1", roles=[role]) | |
| assert user.is_admin() is True | |
| def test_direct_super_admin_role(self, db): | |
| role = _role(db, "SuperAdmin", string_id="super_admin_role") | |
| user = _user(db, "adm2", roles=[role]) | |
| assert user.is_admin() is True | |
| def test_implied_admin_role(self, db): | |
| admin = _role(db, "AdminImplied", string_id="admin_role") | |
| wrapper = _role(db, "Wrapper", string_id="wrapper_role", implied=[admin]) | |
| user = _user(db, "adm3", roles=[wrapper]) | |
| assert user.is_admin() is True | |
| def test_non_admin(self, db): | |
| role = _role(db, "Plain", string_id="plain_role") | |
| user = _user(db, "adm4", roles=[role]) | |
| assert user.is_admin() is False | |
| def test_no_roles(self, db): | |
| user = _user(db, "adm5", roles=[]) | |
| assert user.is_admin() is False | |
| # --------------------------------------------------------------------------- | |
| # get_user_has_roles (classmethod, real DB) | |
| # --------------------------------------------------------------------------- | |
| class TestGetUserHasRoles: | |
| def test_direct_role_holder(self, db): | |
| target_role = _role(db, "Target", string_id="target_role") | |
| other_role = _role(db, "Other", string_id="other_role") | |
| holder = _user(db, "holder", roles=[target_role]) | |
| _user(db, "nonholder", roles=[other_role]) | |
| db.flush() | |
| users = UserModel.get_user_has_roles(["target_role"], db) | |
| ids = {u.id for u in users} | |
| assert holder.id in ids | |
| assert len(ids) == 1 | |
| def test_via_implied_role_mapping(self, db): | |
| # base_role is implied by wrapper_role. A user holding wrapper_role | |
| # (directly) must be returned when querying for base_role. | |
| base_role = _role(db, "Base", string_id="base_role") | |
| wrapper_role = _role( | |
| db, "Wrapper", string_id="wrapper_role", implied=[base_role] | |
| ) | |
| db.flush() | |
| implied_holder = _user(db, "implied_holder", roles=[wrapper_role]) | |
| direct_holder = _user(db, "direct_holder", roles=[base_role]) | |
| unrelated = _role(db, "Unrelated", string_id="unrelated_role") | |
| _user(db, "unrelated_user", roles=[unrelated]) | |
| db.flush() | |
| users = UserModel.get_user_has_roles(["base_role"], db) | |
| ids = {u.id for u in users} | |
| # both the direct holder and the implied (wrapper) holder are returned | |
| assert direct_holder.id in ids | |
| assert implied_holder.id in ids | |
| assert len(ids) == 2 | |
| def test_no_holders_returns_empty(self, db): | |
| _role(db, "Lonely", string_id="lonely_role") | |
| db.flush() | |
| users = UserModel.get_user_has_roles(["lonely_role"], db) | |
| assert users == [] | |
| def test_multiple_role_string_ids(self, db): | |
| ra = _role(db, "RoleA", string_id="role_a") | |
| rb = _role(db, "RoleB", string_id="role_b") | |
| ua = _user(db, "ua", roles=[ra]) | |
| ub = _user(db, "ub", roles=[rb]) | |
| db.flush() | |
| users = UserModel.get_user_has_roles(["role_a", "role_b"], db) | |
| ids = {u.id for u in users} | |
| assert ua.id in ids | |
| assert ub.id in ids | |
Xet Storage Details
- Size:
- 12.3 kB
- Xet hash:
- d0c3dddf8b43b032f6cc355a142b59c99fb9d6f9b29abb557463354404c7d9de
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.