test_admin_role_follows_groups_3533.py 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276
  1. """Moving a user out of Administrators takes their admin rights (#3533).
  2. The setup admin is created with role "admin" and in Administrators, and
  3. ``is_admin`` honours either. Moving them to Operators changed only the groups,
  4. the role kept them an admin, and the UI had no field for it. The groups decide
  5. now and the role follows them, from every path that changes them.
  6. """
  7. import pytest
  8. from httpx import AsyncClient
  9. from sqlalchemy import select
  10. from sqlalchemy.orm import selectinload
  11. from backend.app.models.group import Group
  12. from backend.app.models.settings import Settings
  13. from backend.app.models.user import User
  14. async def _groups(db_session) -> tuple[Group, Group]:
  15. """The seeded system groups, created when the database has none yet."""
  16. found = []
  17. for name in ("Administrators", "Operators"):
  18. group = await db_session.scalar(select(Group).where(Group.name == name))
  19. if group is None:
  20. group = Group(name=name, permissions=[], is_system=True)
  21. db_session.add(group)
  22. await db_session.commit()
  23. found.append(group)
  24. return found[0], found[1]
  25. async def _user(db_session, name: str, role: str, groups: list[Group], active: bool = True) -> int:
  26. from backend.app.core.auth import get_password_hash
  27. user = User(username=name, password_hash=get_password_hash("Whatever1!"), role=role, is_active=active)
  28. user.groups = list(groups)
  29. db_session.add(user)
  30. await db_session.commit()
  31. return user.id
  32. async def _load(db_session, user_id: int) -> User:
  33. db_session.expire_all()
  34. return (
  35. await db_session.execute(select(User).where(User.id == user_id).options(selectinload(User.groups)))
  36. ).scalar_one()
  37. @pytest.mark.asyncio
  38. async def test_moving_an_admin_to_operators_takes_the_admin_rights(async_client: AsyncClient, db_session):
  39. admins, operators = await _groups(db_session)
  40. await _user(db_session, "admin", "admin", [admins])
  41. demoted = await _user(db_session, "mike", "admin", [admins])
  42. # What the edit form sent: the new groups, and the old role back.
  43. response = await async_client.patch(f"/api/v1/users/{demoted}", json={"group_ids": [operators.id], "role": "admin"})
  44. assert response.status_code == 200, response.text
  45. assert response.json()["is_admin"] is False
  46. user = await _load(db_session, demoted)
  47. assert user.role == "user"
  48. assert not user.is_admin
  49. @pytest.mark.asyncio
  50. async def test_moving_a_user_into_administrators_makes_them_admin(async_client: AsyncClient, db_session):
  51. admins, operators = await _groups(db_session)
  52. promoted = await _user(db_session, "jane", "user", [operators])
  53. response = await async_client.patch(f"/api/v1/users/{promoted}", json={"group_ids": [admins.id]})
  54. assert response.status_code == 200, response.text
  55. assert (await _load(db_session, promoted)).role == "admin"
  56. @pytest.mark.asyncio
  57. async def test_role_alone_moves_the_user_out_of_administrators(async_client: AsyncClient, db_session):
  58. admins, operators = await _groups(db_session)
  59. await _user(db_session, "admin", "admin", [admins])
  60. demoted = await _user(db_session, "mike", "admin", [admins, operators])
  61. response = await async_client.patch(f"/api/v1/users/{demoted}", json={"role": "user"})
  62. assert response.status_code == 200, response.text
  63. user = await _load(db_session, demoted)
  64. assert [g.name for g in user.groups] == ["Operators"]
  65. assert not user.is_admin
  66. @pytest.mark.asyncio
  67. async def test_the_last_admin_cannot_be_moved_out_of_administrators(async_client: AsyncClient, db_session):
  68. admins, operators = await _groups(db_session)
  69. only = await _user(db_session, "admin", "admin", [admins])
  70. response = await async_client.patch(f"/api/v1/users/{only}", json={"group_ids": [operators.id]})
  71. assert response.status_code == 400
  72. assert "last admin" in response.json()["detail"]
  73. assert (await _load(db_session, only)).is_admin
  74. @pytest.mark.asyncio
  75. async def test_leaving_administrators_through_the_group_takes_the_admin_rights(async_client: AsyncClient, db_session):
  76. admins, _ = await _groups(db_session)
  77. await _user(db_session, "admin", "admin", [admins])
  78. demoted = await _user(db_session, "mike", "admin", [admins])
  79. response = await async_client.delete(f"/api/v1/groups/{admins.id}/users/{demoted}")
  80. assert response.status_code == 204, response.text
  81. user = await _load(db_session, demoted)
  82. assert user.role == "user"
  83. assert not user.is_admin
  84. @pytest.mark.asyncio
  85. async def test_the_last_admin_cannot_leave_administrators_through_the_group(async_client: AsyncClient, db_session):
  86. admins, _ = await _groups(db_session)
  87. only = await _user(db_session, "admin", "admin", [admins])
  88. response = await async_client.delete(f"/api/v1/groups/{admins.id}/users/{only}")
  89. assert response.status_code == 400
  90. assert (await _load(db_session, only)).is_admin
  91. @pytest.mark.asyncio
  92. async def test_joining_administrators_through_the_group_sets_the_role(async_client: AsyncClient, db_session):
  93. admins, operators = await _groups(db_session)
  94. promoted = await _user(db_session, "jane", "user", [operators])
  95. response = await async_client.post(f"/api/v1/groups/{admins.id}/users/{promoted}")
  96. assert response.status_code == 204, response.text
  97. assert (await _load(db_session, promoted)).role == "admin"
  98. @pytest.mark.asyncio
  99. async def test_a_new_user_gets_the_role_of_their_groups(async_client: AsyncClient, db_session):
  100. admins, operators = await _groups(db_session)
  101. as_operator = await async_client.post(
  102. "/api/v1/users", json={"username": "op", "password": "Whatever1!", "role": "admin", "group_ids": [operators.id]}
  103. )
  104. as_admin = await async_client.post(
  105. "/api/v1/users", json={"username": "ad", "password": "Whatever1!", "role": "admin"}
  106. )
  107. assert as_operator.status_code == 201, as_operator.text
  108. assert as_operator.json()["is_admin"] is False
  109. assert as_admin.status_code == 201, as_admin.text
  110. assert [g["name"] for g in as_admin.json()["groups"]] == ["Administrators"]
  111. class TestBackfill:
  112. """Users demoted before the fix are lined up once at startup."""
  113. FLAG = "_backfill_3533_admin_role_follows_groups_done"
  114. @classmethod
  115. async def _rearm(cls, db_session):
  116. """The app's own startup in the fixture has already run it once."""
  117. from sqlalchemy import delete
  118. await db_session.execute(delete(Settings).where(Settings.key == cls.FLAG))
  119. await db_session.commit()
  120. @staticmethod
  121. async def _run(db_session):
  122. from backend.app.core.database import seed_default_groups
  123. await seed_default_groups()
  124. db_session.expire_all()
  125. @pytest.mark.asyncio
  126. async def test_a_demoted_admin_loses_the_admin_role(self, async_client: AsyncClient, db_session):
  127. admins, operators = await _groups(db_session)
  128. await _user(db_session, "admin", "admin", [admins])
  129. demoted = await _user(db_session, "mike", "admin", [operators])
  130. await self._rearm(db_session)
  131. await self._run(db_session)
  132. user = await _load(db_session, demoted)
  133. assert user.role == "user"
  134. assert not user.is_admin
  135. flag = await db_session.scalar(select(Settings.value).where(Settings.key == self.FLAG))
  136. assert flag == "true"
  137. @pytest.mark.asyncio
  138. async def test_the_only_admin_joins_administrators_instead(self, async_client: AsyncClient, db_session):
  139. _, operators = await _groups(db_session)
  140. only = await _user(db_session, "admin", "admin", [operators])
  141. await self._rearm(db_session)
  142. await self._run(db_session)
  143. user = await _load(db_session, only)
  144. assert user.is_admin
  145. assert "Administrators" in [g.name for g in user.groups]
  146. @pytest.mark.asyncio
  147. async def test_runs_once(self, async_client: AsyncClient, db_session):
  148. admins, operators = await _groups(db_session)
  149. await _user(db_session, "admin", "admin", [admins])
  150. await self._rearm(db_session)
  151. db_session.add(Settings(key=self.FLAG, value="true"))
  152. await db_session.commit()
  153. kept = await _user(db_session, "mike", "admin", [operators])
  154. await self._run(db_session)
  155. assert (await _load(db_session, kept)).role == "admin"
  156. class TestIdentityProviderSync:
  157. """LDAP and OIDC logins set the groups too, so the role follows there."""
  158. @pytest.mark.asyncio
  159. async def test_an_ldap_login_that_drops_administrators_drops_the_role(self, db_session):
  160. from types import SimpleNamespace
  161. from backend.app.api.routes.auth import _sync_ldap_user
  162. admins, operators = await _groups(db_session)
  163. user_id = await _user(db_session, "alice", "admin", [admins])
  164. user = await _load(db_session, user_id)
  165. user.auth_source = "ldap"
  166. user.email = "alice@example.invalid"
  167. await db_session.commit()
  168. await _sync_ldap_user(
  169. db_session,
  170. user,
  171. SimpleNamespace(username="alice", email="alice@example.invalid", groups=["cn=ops"]),
  172. SimpleNamespace(group_mapping={"cn=admins": "Administrators", "cn=ops": "Operators"}, default_group=""),
  173. )
  174. user = await _load(db_session, user_id)
  175. assert [g.name for g in user.groups] == ["Operators"]
  176. assert user.role == "user"
  177. assert not user.is_admin
  178. @pytest.mark.asyncio
  179. async def test_an_oidc_login_into_administrators_sets_the_role(self, db_session):
  180. from backend.app.services.oidc_group_sync import sync_oidc_user_groups
  181. admins, operators = await _groups(db_session)
  182. user_id = await _user(db_session, "bob", "user", [operators])
  183. user = await _load(db_session, user_id)
  184. await sync_oidc_user_groups(
  185. db_session,
  186. user,
  187. group_claim="groups",
  188. group_mapping={"staff": "Administrators"},
  189. claims={"groups": ["staff"]},
  190. )
  191. assert (await _load(db_session, user_id)).role == "admin"
  192. @pytest.mark.asyncio
  193. async def test_an_ldap_user_created_into_administrators_gets_the_role(self, db_session):
  194. from types import SimpleNamespace
  195. from backend.app.api.routes.auth import _provision_ldap_user
  196. await _groups(db_session)
  197. user = await _provision_ldap_user(
  198. db_session,
  199. SimpleNamespace(username="carol", email="carol@example.invalid", groups=["cn=admins"]),
  200. SimpleNamespace(group_mapping={"cn=admins": "Administrators"}, default_group=""),
  201. )
  202. assert (await _load(db_session, user.id)).role == "admin"