mirror of
https://github.com/GNS3/gns3-server.git
synced 2026-11-19 20:55:14 +02:00
Add GET /access/users/me/privileges. It returns the effective privileges of the logged in user, flattened across all roles assigned to the user (directly or through group membership). Superadmins get the full privilege list. This gives clients a way to render their UI based on permissions. The server stays the authority for permission checks: a privilege in the list can still be denied on a specific resource path.
857 lines
35 KiB
Python
857 lines
35 KiB
Python
#!/usr/bin/env python
|
|
#
|
|
# Copyright (C) 2020 GNS3 Technologies Inc.
|
|
#
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
from typing import Optional
|
|
|
|
import pytest
|
|
from fastapi import FastAPI, HTTPException, status
|
|
from httpx import AsyncClient
|
|
from joserfc import jwt
|
|
from joserfc.jwk import OctKey
|
|
from sqlalchemy import update
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
import gns3server.db.models as models
|
|
from gns3server.config import Config
|
|
from gns3server.db.repositories.rbac import RbacRepository
|
|
from gns3server.db.repositories.users import UsersRepository
|
|
from gns3server.schemas.controller.rbac import ACECreate
|
|
from gns3server.schemas.controller.users import User, UserCreate, UserGroupCreate
|
|
from gns3server.services import auth_service
|
|
from gns3server.services.authentication import DEFAULT_JWT_SECRET_KEY
|
|
|
|
pytestmark = pytest.mark.asyncio
|
|
|
|
|
|
class TestUserRoutes:
|
|
async def test_route_exist(self, app: FastAPI, client: AsyncClient) -> None:
|
|
|
|
new_user = {"username": "user1", "email": "user1@email.com", "password": "test_password"}
|
|
response = await client.post(app.url_path_for("create_user"), json=new_user)
|
|
assert response.status_code == status.HTTP_201_CREATED
|
|
|
|
async def test_users_can_register_successfully(
|
|
self, app: FastAPI, client: AsyncClient, db_session: AsyncSession
|
|
) -> None:
|
|
|
|
user_repo = UsersRepository(db_session)
|
|
params = {"username": "user2", "email": "user2@email.com", "password": "test_password"}
|
|
|
|
# make sure the user doesn't exist in the database
|
|
user_in_db = await user_repo.get_user_by_username(params["username"])
|
|
assert user_in_db is None
|
|
|
|
# register the user
|
|
response = await client.post(app.url_path_for("create_user"), json=params)
|
|
assert response.status_code == status.HTTP_201_CREATED
|
|
|
|
# make sure the user does exists in the database now
|
|
user_in_db = await user_repo.get_user_by_username(params["username"])
|
|
assert user_in_db is not None
|
|
assert user_in_db.email == params["email"]
|
|
assert user_in_db.username == params["username"]
|
|
|
|
# check that the user returned in the response is equal to the user in the database
|
|
created_user = User(**response.json()).model_dump_json()
|
|
assert created_user == User.model_validate(user_in_db).model_dump_json()
|
|
|
|
@pytest.mark.parametrize(
|
|
"attr, value, status_code",
|
|
(
|
|
("email", "user2@email.com", status.HTTP_400_BAD_REQUEST),
|
|
("username", "user2", status.HTTP_400_BAD_REQUEST),
|
|
("email", "invalid_email@one@two.io", status.HTTP_422_UNPROCESSABLE_CONTENT),
|
|
("password", "short", status.HTTP_422_UNPROCESSABLE_CONTENT),
|
|
("username", "user2@#$%^<>", status.HTTP_422_UNPROCESSABLE_CONTENT),
|
|
("username", "ab", status.HTTP_422_UNPROCESSABLE_CONTENT),
|
|
),
|
|
)
|
|
async def test_user_registration_fails_when_credentials_are_taken(
|
|
self,
|
|
app: FastAPI,
|
|
client: AsyncClient,
|
|
attr: str,
|
|
value: str,
|
|
status_code: int,
|
|
) -> None:
|
|
|
|
new_user = {"email": "not_taken@email.com", "username": "not_taken_username", "password": "test_password"}
|
|
new_user[attr] = value
|
|
response = await client.post(app.url_path_for("create_user"), json=new_user)
|
|
assert response.status_code == status_code
|
|
|
|
@pytest.mark.parametrize(
|
|
"attr, value, status_code",
|
|
(
|
|
("email", "user@email.com", status.HTTP_200_OK),
|
|
("email", "user@email.com", status.HTTP_400_BAD_REQUEST),
|
|
("username", "user2", status.HTTP_400_BAD_REQUEST),
|
|
("email", "invalid_email@one@two.io", status.HTTP_422_UNPROCESSABLE_CONTENT),
|
|
("password", "short", status.HTTP_422_UNPROCESSABLE_CONTENT),
|
|
("username", "user2@#$%^<>", status.HTTP_422_UNPROCESSABLE_CONTENT),
|
|
("username", "ab", status.HTTP_422_UNPROCESSABLE_CONTENT),
|
|
("full_name", "John Doe", status.HTTP_200_OK),
|
|
("password", "password123", status.HTTP_200_OK),
|
|
("is_active", True, status.HTTP_200_OK),
|
|
),
|
|
)
|
|
async def test_update_user(
|
|
self,
|
|
app: FastAPI,
|
|
client: AsyncClient,
|
|
db_session: AsyncSession,
|
|
attr: str,
|
|
value: str,
|
|
status_code: int,
|
|
) -> None:
|
|
|
|
user_repo = UsersRepository(db_session)
|
|
user_in_db = await user_repo.get_user_by_username("user2")
|
|
update_user = {}
|
|
update_user[attr] = value
|
|
response = await client.put(app.url_path_for("update_user", user_id=user_in_db.user_id), json=update_user)
|
|
assert response.status_code == status_code
|
|
|
|
async def test_users_saved_password_is_hashed(
|
|
self, app: FastAPI, client: AsyncClient, db_session: AsyncSession
|
|
) -> None:
|
|
|
|
user_repo = UsersRepository(db_session)
|
|
new_user = {"username": "user3", "email": "user3@email.com", "password": "test_password"}
|
|
|
|
# send post request to create user and ensure it is successful
|
|
response = await client.post(app.url_path_for("create_user"), json=new_user)
|
|
assert response.status_code == status.HTTP_201_CREATED
|
|
|
|
# ensure that the users password is hashed in the db
|
|
# and that we can verify it using our auth service
|
|
user_in_db = await user_repo.get_user_by_username(new_user["username"])
|
|
assert user_in_db is not None
|
|
assert user_in_db.hashed_password != new_user["password"]
|
|
assert auth_service.verify_password(new_user["password"], user_in_db.hashed_password)
|
|
|
|
async def test_get_users(self, app: FastAPI, client: AsyncClient) -> None:
|
|
|
|
response = await client.get(app.url_path_for("get_users"))
|
|
assert response.status_code == status.HTTP_200_OK
|
|
assert len(response.json()) == 4 # admin, user1, user2 and user3 should exist
|
|
|
|
|
|
class TestAuthTokens:
|
|
async def test_can_create_token_successfully(
|
|
self, app: FastAPI, client: AsyncClient, test_user: User, config: Config
|
|
) -> None:
|
|
|
|
jwt_secret = config.settings.Controller.jwt_secret_key
|
|
token = auth_service.create_access_token(test_user.username)
|
|
key = OctKey.import_key(jwt_secret)
|
|
payload = jwt.decode(token, key, algorithms=["HS256"])
|
|
username = payload.claims.get("sub")
|
|
assert username == test_user.username
|
|
|
|
async def test_decode_token_with_wrong_algorithm(
|
|
self, app: FastAPI, client: AsyncClient, test_user: User, config: Config
|
|
) -> None:
|
|
|
|
jwt_secret = config.settings.Controller.jwt_secret_key
|
|
token = auth_service.create_access_token(test_user.username)
|
|
with pytest.raises(ValueError):
|
|
jwt.decode(token, jwt_secret, algorithms=["HS256"])
|
|
|
|
async def test_can_retrieve_username_from_token(self, app: FastAPI, client: AsyncClient, test_user: User) -> None:
|
|
|
|
token = auth_service.create_access_token(test_user.username)
|
|
username = auth_service.get_username_from_token(token)
|
|
assert username == test_user.username
|
|
|
|
@pytest.mark.parametrize(
|
|
"wrong_secret, wrong_token",
|
|
(
|
|
("use correct secret", "asdf"), # use wrong token
|
|
("use correct secret", ""), # use wrong token
|
|
(OctKey.generate_key().as_dict()["k"], "use correct token"), # use wrong secret
|
|
),
|
|
)
|
|
async def test_error_when_token_or_secret_is_wrong(
|
|
self,
|
|
app: FastAPI,
|
|
client: AsyncClient,
|
|
test_user: User,
|
|
wrong_secret: str,
|
|
wrong_token: Optional[str],
|
|
config,
|
|
) -> None:
|
|
|
|
token = auth_service.create_access_token(test_user.username)
|
|
if wrong_secret == "use correct secret":
|
|
wrong_secret = config.settings.Controller.jwt_secret_key
|
|
if wrong_token == "use correct token":
|
|
wrong_token = token
|
|
with pytest.raises(HTTPException):
|
|
auth_service.get_username_from_token(wrong_token, secret_key=wrong_secret)
|
|
|
|
|
|
class TestUserLogin:
|
|
async def test_user_can_login_successfully_and_receives_valid_token(
|
|
self, app: FastAPI, unauthorized_client: AsyncClient, test_user: User, config: Config
|
|
) -> None:
|
|
|
|
jwt_secret = config.settings.Controller.jwt_secret_key
|
|
unauthorized_client.headers["content-type"] = "application/x-www-form-urlencoded"
|
|
login_data = {
|
|
"username": test_user.username,
|
|
"password": "user1_password",
|
|
}
|
|
response = await unauthorized_client.post(app.url_path_for("login"), data=login_data)
|
|
assert response.status_code == status.HTTP_200_OK
|
|
|
|
# check that token exists in response and has user encoded within it
|
|
token = response.json().get("access_token")
|
|
key = OctKey.import_key(jwt_secret)
|
|
payload = jwt.decode(token, key, algorithms=["HS256"])
|
|
assert "sub" in payload.claims
|
|
assert "ver" in payload.claims
|
|
username = payload.claims.get("sub")
|
|
assert username == test_user.username
|
|
|
|
# check that token is proper type
|
|
assert "token_type" in response.json()
|
|
assert response.json().get("token_type") == "bearer"
|
|
|
|
# check that refresh token is returned
|
|
assert "refresh_token" in response.json()
|
|
assert response.json().get("refresh_token") is not None
|
|
|
|
@pytest.mark.parametrize(
|
|
"username, password, status_code",
|
|
(
|
|
("wrong_username", "user1_password", status.HTTP_401_UNAUTHORIZED),
|
|
("user1", "wrong_password", status.HTTP_401_UNAUTHORIZED),
|
|
("user1", None, status.HTTP_422_UNPROCESSABLE_CONTENT),
|
|
),
|
|
)
|
|
async def test_user_with_wrong_creds_doesnt_receive_token(
|
|
self,
|
|
app: FastAPI,
|
|
unauthorized_client: AsyncClient,
|
|
test_user: User,
|
|
username: str,
|
|
password: str,
|
|
status_code: int,
|
|
) -> None:
|
|
|
|
unauthorized_client.headers["content-type"] = "application/x-www-form-urlencoded"
|
|
login_data = {
|
|
"username": username,
|
|
"password": password,
|
|
}
|
|
if password is None:
|
|
del login_data["password"]
|
|
response = await unauthorized_client.post(app.url_path_for("login"), data=login_data)
|
|
assert response.status_code == status_code
|
|
assert "access_token" not in response.json()
|
|
|
|
|
|
class TestUnauthorizedUser:
|
|
async def test_user_cannot_access_own_data_if_not_authenticated(
|
|
self,
|
|
app: FastAPI,
|
|
unauthorized_client: AsyncClient,
|
|
test_user: User,
|
|
) -> None:
|
|
|
|
response = await unauthorized_client.get(app.url_path_for("get_logged_in_user"))
|
|
assert response.status_code == status.HTTP_401_UNAUTHORIZED
|
|
|
|
async def test_user_can_authenticate_using_json(
|
|
self, app: FastAPI, unauthorized_client: AsyncClient, test_user: User, config: Config
|
|
) -> None:
|
|
|
|
credentials = {
|
|
"username": test_user.username,
|
|
"password": "user1_password",
|
|
}
|
|
response = await unauthorized_client.post(app.url_path_for("authenticate"), json=credentials)
|
|
assert response.status_code == status.HTTP_200_OK
|
|
assert response.json().get("access_token")
|
|
assert response.json().get("refresh_token") is not None
|
|
|
|
token = response.json().get("access_token")
|
|
response = await unauthorized_client.get(app.url_path_for("statistics"), params={"token": token})
|
|
assert response.status_code == status.HTTP_200_OK
|
|
|
|
|
|
class TestUserMe:
|
|
async def test_authenticated_user_can_retrieve_own_data(
|
|
self,
|
|
app: FastAPI,
|
|
authorized_client: AsyncClient,
|
|
test_user: User,
|
|
) -> None:
|
|
|
|
response = await authorized_client.get(app.url_path_for("get_logged_in_user"))
|
|
assert response.status_code == status.HTTP_200_OK
|
|
user = User(**response.json())
|
|
assert user.username == test_user.username
|
|
assert user.email == test_user.email
|
|
assert user.user_id == test_user.user_id
|
|
|
|
async def test_authenticated_user_can_update_own_data(
|
|
self,
|
|
app: FastAPI,
|
|
authorized_client: AsyncClient,
|
|
test_user: User,
|
|
) -> None:
|
|
|
|
response = await authorized_client.get(app.url_path_for("get_logged_in_user"))
|
|
assert response.status_code == status.HTTP_200_OK
|
|
user = User(**response.json())
|
|
assert user.username == test_user.username
|
|
assert user.email == test_user.email
|
|
assert user.user_id == test_user.user_id
|
|
|
|
# logged-in users can only change their email, full name and password
|
|
@pytest.mark.parametrize(
|
|
"attr, value, status_code",
|
|
(
|
|
("email", "user42@email.com", status.HTTP_200_OK),
|
|
("email", "user42@email.com", status.HTTP_400_BAD_REQUEST),
|
|
("full_name", "John Doe", status.HTTP_200_OK),
|
|
("password", "password123", status.HTTP_200_OK),
|
|
),
|
|
)
|
|
async def test_authenticated_user_can_update_own_data(
|
|
self,
|
|
app: FastAPI,
|
|
authorized_client: AsyncClient,
|
|
attr: str,
|
|
value: str,
|
|
status_code: int,
|
|
) -> None:
|
|
|
|
update_user = {}
|
|
update_user[attr] = value
|
|
response = await authorized_client.put(app.url_path_for("update_logged_in_user"), json=update_user)
|
|
assert response.status_code == status_code
|
|
|
|
|
|
class TestLogout:
|
|
async def test_logout_returns_no_content(
|
|
self,
|
|
app: FastAPI,
|
|
unauthorized_client: AsyncClient,
|
|
test_user: User,
|
|
) -> None:
|
|
|
|
# login to get a fresh token that includes token_version
|
|
credentials = {"username": test_user.username, "password": "user1_password"}
|
|
response = await unauthorized_client.post(app.url_path_for("authenticate"), json=credentials)
|
|
assert response.status_code == status.HTTP_200_OK
|
|
token = response.json()["access_token"]
|
|
|
|
response = await unauthorized_client.post(
|
|
app.url_path_for("logout"), headers={"Authorization": f"Bearer {token}"}
|
|
)
|
|
assert response.status_code == status.HTTP_204_NO_CONTENT
|
|
|
|
async def test_token_is_rejected_after_logout(
|
|
self,
|
|
app: FastAPI,
|
|
unauthorized_client: AsyncClient,
|
|
test_user: User,
|
|
db_session: AsyncSession,
|
|
) -> None:
|
|
|
|
# login and get a token
|
|
credentials = {"username": test_user.username, "password": "user1_password"}
|
|
response = await unauthorized_client.post(app.url_path_for("authenticate"), json=credentials)
|
|
assert response.status_code == status.HTTP_200_OK
|
|
token = response.json()["access_token"]
|
|
|
|
# logout — increments token_version
|
|
await unauthorized_client.post(app.url_path_for("logout"), headers={"Authorization": f"Bearer {token}"})
|
|
|
|
# old token must now be rejected
|
|
response = await unauthorized_client.get(
|
|
app.url_path_for("get_logged_in_user"), headers={"Authorization": f"Bearer {token}"}
|
|
)
|
|
assert response.status_code == status.HTTP_401_UNAUTHORIZED
|
|
assert response.json()["message"] == f"Token has been revoked for '{test_user.username}'"
|
|
|
|
async def test_new_token_works_after_logout_and_relogin(
|
|
self,
|
|
app: FastAPI,
|
|
unauthorized_client: AsyncClient,
|
|
test_user: User,
|
|
) -> None:
|
|
|
|
credentials = {"username": test_user.username, "password": "user1_password"}
|
|
|
|
# login, then logout
|
|
response = await unauthorized_client.post(app.url_path_for("authenticate"), json=credentials)
|
|
old_token = response.json()["access_token"]
|
|
await unauthorized_client.post(app.url_path_for("logout"), headers={"Authorization": f"Bearer {old_token}"})
|
|
|
|
# login again to get a fresh token
|
|
response = await unauthorized_client.post(app.url_path_for("authenticate"), json=credentials)
|
|
assert response.status_code == status.HTTP_200_OK
|
|
new_token = response.json()["access_token"]
|
|
|
|
# new token must work
|
|
response = await unauthorized_client.get(
|
|
app.url_path_for("get_logged_in_user"), headers={"Authorization": f"Bearer {new_token}"}
|
|
)
|
|
assert response.status_code == status.HTTP_200_OK
|
|
assert response.json()["username"] == test_user.username
|
|
|
|
async def test_stale_version_token_is_rejected(
|
|
self,
|
|
app: FastAPI,
|
|
unauthorized_client: AsyncClient,
|
|
test_user: User,
|
|
db_session: AsyncSession,
|
|
) -> None:
|
|
|
|
# craft a token with ver=0 while the user's token_version is already higher
|
|
user_repo = UsersRepository(db_session)
|
|
user_in_db = await user_repo.get_user_by_username(test_user.username)
|
|
|
|
# force token_version ahead so any ver=0 token is stale
|
|
await user_repo.logout_user(user_in_db.user_id)
|
|
|
|
stale_token = auth_service.create_access_token(test_user.username, token_version=0)
|
|
response = await unauthorized_client.get(
|
|
app.url_path_for("get_logged_in_user"), headers={"Authorization": f"Bearer {stale_token}"}
|
|
)
|
|
assert response.status_code == status.HTTP_401_UNAUTHORIZED
|
|
|
|
async def test_logout_without_token_returns_unauthorized(
|
|
self,
|
|
app: FastAPI,
|
|
unauthorized_client: AsyncClient,
|
|
) -> None:
|
|
|
|
response = await unauthorized_client.post(app.url_path_for("logout"))
|
|
assert response.status_code == status.HTTP_401_UNAUTHORIZED
|
|
|
|
|
|
class TestTokenLifetime:
|
|
async def _issue(self, app, client, user, endpoint):
|
|
credentials = {"username": user.username, "password": "user1_password"}
|
|
if endpoint == "login":
|
|
return await client.post(
|
|
app.url_path_for("login"),
|
|
data=credentials,
|
|
headers={"content-type": "application/x-www-form-urlencoded"},
|
|
)
|
|
auth = await client.post(app.url_path_for("authenticate"), json=credentials)
|
|
if endpoint == "authenticate":
|
|
return auth
|
|
return await client.post(
|
|
app.url_path_for("refresh_access_token"), json={"refresh_token": auth.json()["refresh_token"]}
|
|
)
|
|
|
|
@pytest.mark.parametrize("endpoint", ("login", "authenticate", "refresh_access_token"))
|
|
async def test_token_response_includes_lifetimes(
|
|
self,
|
|
app: FastAPI,
|
|
unauthorized_client: AsyncClient,
|
|
test_user: User,
|
|
config: Config,
|
|
endpoint: str,
|
|
) -> None:
|
|
|
|
response = await self._issue(app, unauthorized_client, test_user, endpoint)
|
|
assert response.status_code == status.HTTP_200_OK
|
|
body = response.json()
|
|
controller = config.settings.Controller
|
|
assert body["expires_in"] == controller.jwt_access_token_expire_minutes * 60
|
|
assert body["refresh_expires_in"] == controller.jwt_refresh_token_expire_minutes * 60
|
|
assert body["access_token"]
|
|
assert body["token_type"] == "bearer"
|
|
assert body["refresh_token"]
|
|
|
|
@pytest.mark.parametrize("endpoint", ("login", "authenticate", "refresh_access_token"))
|
|
async def test_expires_in_matches_jwt_claims(
|
|
self,
|
|
app: FastAPI,
|
|
unauthorized_client: AsyncClient,
|
|
test_user: User,
|
|
config: Config,
|
|
endpoint: str,
|
|
) -> None:
|
|
|
|
response = await self._issue(app, unauthorized_client, test_user, endpoint)
|
|
body = response.json()
|
|
key = OctKey.import_key(config.settings.Controller.jwt_secret_key)
|
|
access = jwt.decode(body["access_token"], key, algorithms=["HS256"]).claims
|
|
refresh = jwt.decode(body["refresh_token"], key, algorithms=["HS256"]).claims
|
|
assert access["exp"] - access["iat"] == body["expires_in"]
|
|
assert refresh["exp"] - refresh["iat"] == body["refresh_expires_in"]
|
|
|
|
async def test_openapi_declares_token_lifetimes_as_integers(self, app: FastAPI) -> None:
|
|
|
|
schema = app.openapi()["components"]["schemas"]["Token"]
|
|
assert schema["properties"]["expires_in"]["type"] == "integer"
|
|
refresh_expires_in = schema["properties"]["refresh_expires_in"]
|
|
assert "integer" in str(refresh_expires_in)
|
|
assert "expires_in" in schema["required"]
|
|
|
|
async def test_openapi_security_scheme_mentions_api_keys(self, app: FastAPI) -> None:
|
|
|
|
schemes = app.openapi()["components"]["securitySchemes"]
|
|
assert any("API key" in scheme.get("description", "") for scheme in schemes.values())
|
|
|
|
|
|
class TestRefreshToken:
|
|
async def test_login_returns_refresh_token(
|
|
self,
|
|
app: FastAPI,
|
|
unauthorized_client: AsyncClient,
|
|
test_user: User,
|
|
) -> None:
|
|
|
|
credentials = {"username": test_user.username, "password": "user1_password"}
|
|
response = await unauthorized_client.post(
|
|
app.url_path_for("login"), data=credentials, headers={"content-type": "application/x-www-form-urlencoded"}
|
|
)
|
|
assert response.status_code == status.HTTP_200_OK
|
|
assert "refresh_token" in response.json()
|
|
assert response.json().get("refresh_token") is not None
|
|
|
|
async def test_authenticate_returns_refresh_token(
|
|
self,
|
|
app: FastAPI,
|
|
unauthorized_client: AsyncClient,
|
|
test_user: User,
|
|
) -> None:
|
|
|
|
credentials = {"username": test_user.username, "password": "user1_password"}
|
|
response = await unauthorized_client.post(app.url_path_for("authenticate"), json=credentials)
|
|
assert response.status_code == status.HTTP_200_OK
|
|
assert "refresh_token" in response.json()
|
|
assert response.json().get("refresh_token") is not None
|
|
|
|
async def test_refresh_endpoint_returns_new_tokens(
|
|
self,
|
|
app: FastAPI,
|
|
unauthorized_client: AsyncClient,
|
|
test_user: User,
|
|
) -> None:
|
|
|
|
# authenticate to get a refresh token
|
|
credentials = {"username": test_user.username, "password": "user1_password"}
|
|
auth_response = await unauthorized_client.post(app.url_path_for("authenticate"), json=credentials)
|
|
refresh_token = auth_response.json()["refresh_token"]
|
|
|
|
# use the refresh token at /refresh
|
|
response = await unauthorized_client.post(
|
|
app.url_path_for("refresh_access_token"),
|
|
json={"refresh_token": refresh_token},
|
|
)
|
|
assert response.status_code == status.HTTP_200_OK
|
|
assert "access_token" in response.json()
|
|
assert response.json().get("token_type") == "bearer"
|
|
assert "refresh_token" in response.json()
|
|
assert response.json().get("refresh_token") is not None
|
|
|
|
async def test_new_access_token_from_refresh_works_on_protected_route(
|
|
self,
|
|
app: FastAPI,
|
|
unauthorized_client: AsyncClient,
|
|
test_user: User,
|
|
) -> None:
|
|
|
|
credentials = {"username": test_user.username, "password": "user1_password"}
|
|
auth_response = await unauthorized_client.post(app.url_path_for("authenticate"), json=credentials)
|
|
refresh_token = auth_response.json()["refresh_token"]
|
|
|
|
# refresh to get a new access token
|
|
refresh_response = await unauthorized_client.post(
|
|
app.url_path_for("refresh_access_token"),
|
|
json={"refresh_token": refresh_token},
|
|
)
|
|
new_access_token = refresh_response.json()["access_token"]
|
|
|
|
# the new access token must work on a protected route
|
|
response = await unauthorized_client.get(
|
|
app.url_path_for("get_logged_in_user"),
|
|
headers={"Authorization": f"Bearer {new_access_token}"},
|
|
)
|
|
assert response.status_code == status.HTTP_200_OK
|
|
assert response.json()["username"] == test_user.username
|
|
|
|
async def test_refresh_with_stale_token_after_logout(
|
|
self,
|
|
app: FastAPI,
|
|
unauthorized_client: AsyncClient,
|
|
test_user: User,
|
|
) -> None:
|
|
|
|
# authenticate and get a refresh token
|
|
credentials = {"username": test_user.username, "password": "user1_password"}
|
|
auth_response = await unauthorized_client.post(app.url_path_for("authenticate"), json=credentials)
|
|
refresh_token = auth_response.json()["refresh_token"]
|
|
|
|
# logout — bumps token_version, invalidating the refresh token
|
|
access_token = auth_response.json()["access_token"]
|
|
await unauthorized_client.post(app.url_path_for("logout"), headers={"Authorization": f"Bearer {access_token}"})
|
|
|
|
# /refresh must now reject the stale refresh token
|
|
response = await unauthorized_client.post(
|
|
app.url_path_for("refresh_access_token"),
|
|
json={"refresh_token": refresh_token},
|
|
)
|
|
assert response.status_code == status.HTTP_401_UNAUTHORIZED
|
|
|
|
async def test_refresh_rejects_access_token(
|
|
self,
|
|
app: FastAPI,
|
|
unauthorized_client: AsyncClient,
|
|
test_user: User,
|
|
) -> None:
|
|
|
|
# an access token presented at /refresh must be rejected
|
|
credentials = {"username": test_user.username, "password": "user1_password"}
|
|
auth_response = await unauthorized_client.post(app.url_path_for("authenticate"), json=credentials)
|
|
access_token = auth_response.json()["access_token"]
|
|
|
|
response = await unauthorized_client.post(
|
|
app.url_path_for("refresh_access_token"),
|
|
json={"refresh_token": access_token},
|
|
)
|
|
assert response.status_code == status.HTTP_401_UNAUTHORIZED
|
|
|
|
async def test_refresh_rejects_expired_token(
|
|
self,
|
|
app: FastAPI,
|
|
unauthorized_client: AsyncClient,
|
|
test_user: User,
|
|
) -> None:
|
|
|
|
# a refresh token with an already-expired timestamp
|
|
expired_refresh = auth_service.create_refresh_token(test_user.username, expires_in=-1)
|
|
|
|
response = await unauthorized_client.post(
|
|
app.url_path_for("refresh_access_token"),
|
|
json={"refresh_token": expired_refresh},
|
|
)
|
|
assert response.status_code == status.HTTP_401_UNAUTHORIZED
|
|
|
|
async def test_refresh_rejects_invalid_token(
|
|
self,
|
|
app: FastAPI,
|
|
unauthorized_client: AsyncClient,
|
|
) -> None:
|
|
|
|
response = await unauthorized_client.post(
|
|
app.url_path_for("refresh_access_token"),
|
|
json={"refresh_token": "not-a-valid-token"},
|
|
)
|
|
assert response.status_code == status.HTTP_401_UNAUTHORIZED
|
|
|
|
async def test_refresh_token_rejected_as_bearer(
|
|
self,
|
|
app: FastAPI,
|
|
unauthorized_client: AsyncClient,
|
|
test_user: User,
|
|
) -> None:
|
|
|
|
# a refresh token used as a bearer access token must be rejected
|
|
credentials = {"username": test_user.username, "password": "user1_password"}
|
|
auth_response = await unauthorized_client.post(app.url_path_for("authenticate"), json=credentials)
|
|
refresh_token = auth_response.json()["refresh_token"]
|
|
|
|
response = await unauthorized_client.get(
|
|
app.url_path_for("get_logged_in_user"),
|
|
headers={"Authorization": f"Bearer {refresh_token}"},
|
|
)
|
|
assert response.status_code == status.HTTP_401_UNAUTHORIZED
|
|
|
|
|
|
class TestSuperAdmin:
|
|
async def test_super_admin_exists(self, app: FastAPI, client: AsyncClient, db_session: AsyncSession) -> None:
|
|
|
|
user_repo = UsersRepository(db_session)
|
|
admin_in_db = await user_repo.get_user_by_username("admin")
|
|
assert admin_in_db is not None
|
|
assert auth_service.verify_password("admin", admin_in_db.hashed_password)
|
|
|
|
async def test_cannot_delete_super_admin(self, app: FastAPI, client: AsyncClient, db_session: AsyncSession) -> None:
|
|
|
|
user_repo = UsersRepository(db_session)
|
|
admin_in_db = await user_repo.get_user_by_username("admin")
|
|
response = await client.delete(app.url_path_for("delete_user", user_id=admin_in_db.user_id))
|
|
assert response.status_code == status.HTTP_403_FORBIDDEN
|
|
|
|
async def test_admin_can_login_after_password_recovery(
|
|
self, app: FastAPI, unauthorized_client: AsyncClient, db_session: AsyncSession
|
|
) -> None:
|
|
|
|
# set the admin password to null in the database
|
|
query = update(models.User).where(models.User.username == "admin").values(hashed_password=None)
|
|
await db_session.execute(query)
|
|
await db_session.commit()
|
|
|
|
unauthorized_client.headers["content-type"] = "application/x-www-form-urlencoded"
|
|
login_data = {
|
|
"username": "admin",
|
|
"password": "whatever",
|
|
}
|
|
response = await unauthorized_client.post(app.url_path_for("login"), data=login_data)
|
|
assert response.status_code == status.HTTP_200_OK
|
|
|
|
|
|
class TestUserPrivileges:
|
|
"""
|
|
Tests for GET /access/users/me/privileges.
|
|
|
|
Every test creates its own users, groups and ACEs: no shared rows with
|
|
other tests in this file, and authentication is sent per-request so the
|
|
class stays order-independent.
|
|
"""
|
|
|
|
async def _create_user(self, db_session: AsyncSession, username: str) -> models.User:
|
|
|
|
return await UsersRepository(db_session).create_user(
|
|
UserCreate(username=username, email=f"{username}@email.com", password="secret_password")
|
|
)
|
|
|
|
async def _create_group_with_member(
|
|
self, db_session: AsyncSession, name: str, user: models.User
|
|
) -> models.UserGroup:
|
|
|
|
users_repo = UsersRepository(db_session)
|
|
group = await users_repo.create_user_group(UserGroupCreate(name=name))
|
|
await users_repo.add_member_to_user_group(group.user_group_id, user)
|
|
return group
|
|
|
|
@staticmethod
|
|
def _headers(username: str) -> dict:
|
|
|
|
token = auth_service.create_access_token(username, secret_key=DEFAULT_JWT_SECRET_KEY)
|
|
return {"Authorization": f"Bearer {token}"}
|
|
|
|
async def test_superadmin_gets_all_privileges(
|
|
self, app: FastAPI, client: AsyncClient, db_session: AsyncSession
|
|
) -> None:
|
|
|
|
rbac_repo = RbacRepository(db_session)
|
|
expected = sorted(privilege.name for privilege in await rbac_repo.get_privileges())
|
|
|
|
response = await client.get(app.url_path_for("get_logged_in_user_privileges"), headers=self._headers("admin"))
|
|
assert response.status_code == status.HTTP_200_OK
|
|
data = response.json()
|
|
assert data["is_superadmin"] is True
|
|
assert data["privileges"] == expected
|
|
|
|
async def test_user_without_ace_has_no_privileges(
|
|
self, app: FastAPI, client: AsyncClient, db_session: AsyncSession
|
|
) -> None:
|
|
|
|
user = await self._create_user(db_session, "priv_no_ace")
|
|
response = await client.get(
|
|
app.url_path_for("get_logged_in_user_privileges"), headers=self._headers(user.username)
|
|
)
|
|
assert response.status_code == status.HTTP_200_OK
|
|
data = response.json()
|
|
assert data["is_superadmin"] is False
|
|
assert data["privileges"] == []
|
|
|
|
async def test_privileges_from_user_ace(self, app: FastAPI, client: AsyncClient, db_session: AsyncSession) -> None:
|
|
|
|
user = await self._create_user(db_session, "priv_user_ace")
|
|
rbac_repo = RbacRepository(db_session)
|
|
role = await rbac_repo.get_role_by_name("Administrator")
|
|
await rbac_repo.create_ace(
|
|
ACECreate(path="/projects", ace_type="user", user_id=user.user_id, role_id=role.role_id)
|
|
)
|
|
expected = sorted(privilege.name for privilege in await rbac_repo.get_role_privileges(role.role_id))
|
|
|
|
response = await client.get(
|
|
app.url_path_for("get_logged_in_user_privileges"), headers=self._headers(user.username)
|
|
)
|
|
assert response.status_code == status.HTTP_200_OK
|
|
assert response.json()["privileges"] == expected
|
|
|
|
async def test_privileges_from_group_ace(self, app: FastAPI, client: AsyncClient, db_session: AsyncSession) -> None:
|
|
|
|
user = await self._create_user(db_session, "priv_group_ace")
|
|
group = await self._create_group_with_member(db_session, "priv_group", user)
|
|
rbac_repo = RbacRepository(db_session)
|
|
role = await rbac_repo.get_role_by_name("Auditor")
|
|
await rbac_repo.create_ace(
|
|
ACECreate(path="/projects", ace_type="group", group_id=group.user_group_id, role_id=role.role_id)
|
|
)
|
|
expected = sorted(privilege.name for privilege in await rbac_repo.get_role_privileges(role.role_id))
|
|
|
|
response = await client.get(
|
|
app.url_path_for("get_logged_in_user_privileges"), headers=self._headers(user.username)
|
|
)
|
|
assert response.status_code == status.HTTP_200_OK
|
|
assert response.json()["privileges"] == expected
|
|
|
|
async def test_privileges_are_the_union_of_user_and_group_aces(
|
|
self, app: FastAPI, client: AsyncClient, db_session: AsyncSession
|
|
) -> None:
|
|
|
|
user = await self._create_user(db_session, "priv_union")
|
|
group = await self._create_group_with_member(db_session, "priv_union_group", user)
|
|
rbac_repo = RbacRepository(db_session)
|
|
user_role = await rbac_repo.get_role_by_name("Auditor")
|
|
group_role = await rbac_repo.get_role_by_name("User")
|
|
await rbac_repo.create_ace(
|
|
ACECreate(path="/projects", ace_type="user", user_id=user.user_id, role_id=user_role.role_id)
|
|
)
|
|
await rbac_repo.create_ace(
|
|
ACECreate(path="/templates", ace_type="group", group_id=group.user_group_id, role_id=group_role.role_id)
|
|
)
|
|
expected = set(privilege.name for privilege in await rbac_repo.get_role_privileges(user_role.role_id))
|
|
expected.update(privilege.name for privilege in await rbac_repo.get_role_privileges(group_role.role_id))
|
|
|
|
response = await client.get(
|
|
app.url_path_for("get_logged_in_user_privileges"), headers=self._headers(user.username)
|
|
)
|
|
assert response.status_code == status.HTTP_200_OK
|
|
data = response.json()
|
|
assert data["is_superadmin"] is False
|
|
assert data["privileges"] == sorted(expected)
|
|
|
|
async def test_denial_ace_is_not_reported_as_a_privilege(
|
|
self, app: FastAPI, client: AsyncClient, db_session: AsyncSession
|
|
) -> None:
|
|
|
|
user = await self._create_user(db_session, "priv_denied")
|
|
rbac_repo = RbacRepository(db_session)
|
|
role = await rbac_repo.get_role_by_name("Administrator")
|
|
await rbac_repo.create_ace(
|
|
ACECreate(path="/projects", ace_type="user", user_id=user.user_id, role_id=role.role_id, allowed=False)
|
|
)
|
|
|
|
response = await client.get(
|
|
app.url_path_for("get_logged_in_user_privileges"), headers=self._headers(user.username)
|
|
)
|
|
assert response.status_code == status.HTTP_200_OK
|
|
assert response.json()["privileges"] == []
|
|
|
|
async def test_privileges_require_authentication(self, app: FastAPI, client: AsyncClient) -> None:
|
|
|
|
response = await client.get(
|
|
app.url_path_for("get_logged_in_user_privileges"), headers={"Authorization": "Bearer invalid_token"}
|
|
)
|
|
assert response.status_code == status.HTTP_401_UNAUTHORIZED
|