Files

225 lines
9.5 KiB
Python
Raw Permalink Normal View History

2026-11-16 20:45:22 +08:00
from __future__ import annotations
import tempfile
from pathlib import Path
from unittest import TestCase
from fastapi.testclient import TestClient
from jose import jwt
from sqlalchemy import create_engine, select
from sqlalchemy.orm import sessionmaker
from sakura_cloud.core.config import settings
from sakura_cloud.core.security import create_access_token, create_refresh_token, hash_password
from sakura_cloud.db.base import Base
from sakura_cloud.db.session import get_db
from sakura_cloud.main import create_app
from sakura_cloud.models.admin import AdminAuditLog
from sakura_cloud.models.user import User, UserRole
from sakura_cloud.core.logging import logger
class AdminConsoleSecurityTest(TestCase):
def setUp(self) -> None:
self.temp_dir = tempfile.TemporaryDirectory()
self.root = Path(self.temp_dir.name)
self.db_path = self.root / "cloud.db"
self.engine = create_engine(f"sqlite:///{self.db_path}", connect_args={"check_same_thread": False})
self.SessionLocal = sessionmaker(bind=self.engine, autoflush=False, autocommit=False)
Base.metadata.create_all(self.engine)
self.old_cors = settings.cors_origins
self.old_log_dir = settings.log_dir
settings.cors_origins = ["http://admin.example.test"]
settings.log_dir = str(self.root / "logs")
Path(settings.log_dir).mkdir(parents=True, exist_ok=True)
self.app = create_app()
self.app.dependency_overrides[get_db] = self._override_db
self.client = TestClient(self.app)
self.user_id = "user"
self.admin_id = "admin"
self.super_id = "super"
with self.SessionLocal() as db:
db.add_all(
[
User(
id=self.user_id,
username="user",
email="user@example.test",
password_hash=hash_password("password123"),
role=UserRole.USER,
),
User(
id=self.admin_id,
username="admin",
email="admin@example.test",
password_hash=hash_password("password123"),
role=UserRole.ADMIN,
),
User(
id=self.super_id,
username="root",
email="root@example.test",
password_hash=hash_password("password123"),
role=UserRole.SUPER_ADMIN,
),
]
)
db.commit()
self.user_auth = {"Authorization": f"Bearer {create_access_token(self.user_id)}"}
self.admin_auth = {"Authorization": f"Bearer {create_access_token(self.admin_id)}"}
self.super_auth = {"Authorization": f"Bearer {create_access_token(self.super_id)}"}
def tearDown(self) -> None:
self.client.close()
self.engine.dispose()
logger.remove()
settings.cors_origins = self.old_cors
settings.log_dir = self.old_log_dir
try:
self.temp_dir.cleanup()
except PermissionError:
pass
def _override_db(self):
db = self.SessionLocal()
try:
yield db
finally:
db.close()
def test_admin_requires_login_and_role(self) -> None:
self.assertEqual(self.client.get("/api/v1/admin/dashboard").status_code, 401)
self.assertEqual(self.client.get("/api/v1/admin/dashboard", headers=self.user_auth).status_code, 403)
self.assertEqual(self.client.get("/api/v1/admin/dashboard", headers=self.admin_auth).status_code, 200)
def test_admin_cannot_disable_super_admin(self) -> None:
response = self.client.patch(
f"/api/v1/admin/users/{self.super_id}/status",
headers=self.admin_auth,
json={"is_active": False},
)
self.assertEqual(response.status_code, 403)
def test_invalid_query_params_return_422(self) -> None:
response = self.client.get("/api/v1/admin/users?sort=password_hash", headers=self.admin_auth)
self.assertEqual(response.status_code, 422)
def test_sensitive_fields_are_not_returned(self) -> None:
response = self.client.get("/api/v1/admin/users", headers=self.admin_auth)
self.assertEqual(response.status_code, 200)
text = response.text
self.assertNotIn("password_hash", text)
self.assertNotIn("password123", text)
self.assertIn("admin@example.test", text)
def test_audit_log_is_written_for_disable_user(self) -> None:
response = self.client.patch(
f"/api/v1/admin/users/{self.user_id}/status",
headers=self.admin_auth,
json={"is_active": False},
)
self.assertEqual(response.status_code, 200)
with self.SessionLocal() as db:
row = db.scalar(
select(AdminAuditLog).where(
AdminAuditLog.admin_user_id == self.admin_id,
AdminAuditLog.action == "disable_user",
AdminAuditLog.target_id == self.user_id,
)
)
self.assertIsNotNone(row)
self.assertEqual(row.detail_json["is_active"], False)
def test_admin_login_writes_audit_log(self) -> None:
response = self.client.post(
"/api/v1/admin/login",
json={"username_or_email": "admin", "password": "password123"},
)
self.assertEqual(response.status_code, 200)
self.assertIn("access_token", response.json()["data"])
with self.SessionLocal() as db:
row = db.scalar(select(AdminAuditLog).where(AdminAuditLog.action == "admin_login"))
self.assertIsNotNone(row)
def test_login_does_not_revoke_another_device_access_token(self) -> None:
response = self.client.post(
"/api/v1/auth/login",
json={"username_or_email": "user", "password": "password123"},
)
self.assertEqual(response.status_code, 200)
with self.SessionLocal() as db:
self.assertEqual(db.get(User, self.user_id).token_version, 0)
def test_refresh_does_not_revoke_other_device_tokens(self) -> None:
first_refresh_token = create_refresh_token(self.user_id)
second_refresh_token = create_refresh_token(self.user_id)
first_response = self.client.post(
"/api/v1/auth/refresh",
json={"refresh_token": first_refresh_token},
)
self.assertEqual(first_response.status_code, 200)
with self.SessionLocal() as db:
self.assertEqual(db.get(User, self.user_id).token_version, 0)
second_response = self.client.post(
"/api/v1/auth/refresh",
json={"refresh_token": second_refresh_token},
)
self.assertEqual(second_response.status_code, 200)
def test_security_headers_and_cors_are_present(self) -> None:
response = self.client.get(
"/api/v1/admin/dashboard",
headers={**self.admin_auth, "Origin": "http://admin.example.test"},
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.headers["X-Content-Type-Options"], "nosniff")
self.assertEqual(response.headers["X-Frame-Options"], "DENY")
self.assertIn("Referrer-Policy", response.headers)
self.assertIn("Content-Security-Policy", response.headers)
self.assertEqual(response.headers.get("Access-Control-Allow-Origin"), "http://admin.example.test")
self.assertEqual(response.headers["Referrer-Policy"], "no-referrer")
self.assertIn("Permissions-Policy", response.headers)
def test_disabled_user_access_and_refresh_are_rejected(self) -> None:
refresh_token = create_refresh_token(self.user_id)
with self.SessionLocal() as db:
user = db.get(User, self.user_id)
user.is_active = False
user.token_version += 1
db.commit()
response = self.client.get("/api/v1/me", headers=self.user_auth)
self.assertEqual(response.status_code, 401)
refresh_response = self.client.post("/api/v1/auth/refresh", json={"refresh_token": refresh_token})
self.assertEqual(refresh_response.status_code, 401)
def test_jwt_missing_exp_wrong_type_and_tampered_are_rejected(self) -> None:
no_exp = jwt.encode({"sub": self.user_id, "type": "access"}, settings.jwt_secret_key, algorithm=settings.jwt_algorithm)
wrong_type = jwt.encode({"sub": self.user_id, "type": "reset", "exp": 4102444800}, settings.jwt_secret_key, algorithm=settings.jwt_algorithm)
valid = create_access_token(self.user_id)
tampered = valid[:-1] + ("a" if valid[-1] != "a" else "b")
for token in (no_exp, wrong_type, tampered):
response = self.client.get("/api/v1/me", headers={"Authorization": f"Bearer {token}"})
self.assertEqual(response.status_code, 401)
def test_admin_role_changes_require_super_admin(self) -> None:
response = self.client.patch(
f"/api/v1/admin/users/{self.user_id}/role",
headers=self.admin_auth,
json={"role": "admin"},
)
self.assertEqual(response.status_code, 403)
response = self.client.patch(
f"/api/v1/admin/users/{self.user_id}/role",
headers=self.super_auth,
json={"role": "admin"},
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()["data"]["role"], "admin")