OpenRAG is a comprehensive, single package Retrieval-Augmented Generation platform built on Langflow, Docling, and Opensearch.
Python
"""Phase 2: end-to-end gate test for require_permission.
Builds a tiny FastAPI app whose routes use the real `require_permission`
dependency against an in-memory SQLite seeded with the real catalog. The
in-process auth dependency is overridden via FastAPI's dependency_overrides
so we can switch between admin / developer / user / viewer personas per
request without touching cookies or JWTs.
"""
import sys
from pathlib import Path
import httpx
import pytest
import pytest_asyncio
from fastapi import Depends, FastAPI, Request
from fastapi.responses import JSONResponse
from sqlalchemy import select
from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
from sqlmodel import SQLModel
ROOT = Path(__file__).resolve().parent.parent.parent.parent
SRC = ROOT / "src"
if str(SRC) not in sys.path:
sys.path.insert(0, str(SRC))
import db.models # noqa: E402,F401
from auth.user_identity_cache import _ENSURED_USER_IDS, _user_cache_key # noqa: E402
from db.models import ( # noqa: E402
Permission,
Role,
RolePermission,
)
from db.models import User as UserRow # noqa: E402
from db.repositories import RoleRepo # noqa: E402
from db.seed import seed_roles_and_permissions # noqa: E402
from dependencies import ( # noqa: E402
get_current_user,
get_rbac_service,
require_all_permissions,
require_any_permission,
require_permission,
)
from services.rbac_service import RBACService # noqa: E402
from services.user_service import ensure_user_row # noqa: E402
from session_manager import User # noqa: E402
# Map role-name -> User dataclass we hand to overrides
PERSONAS: dict[str, User] = {}
require_document_delete_permission = require_any_permission(
("knowledge:delete:own", "knowledge:delete:anonymous")
)
@pytest_asyncio.fixture
async def app(monkeypatch):
monkeypatch.setenv("OPENRAG_DEFAULT_ROLE", "user")
engine = create_async_engine(
"sqlite+aiosqlite:///:memory:",
connect_args={"check_same_thread": False},
)
async with engine.begin() as conn:
await conn.run_sync(SQLModel.metadata.create_all)
SessionLocal = async_sessionmaker(engine, expire_on_commit=False)
PERSONAS.clear()
async with SessionLocal() as s:
await seed_roles_and_permissions(s)
# Every user gets OPENRAG_DEFAULT_ROLE = "user"; promote personas
# explicitly (no bootstrap-admin rule).
admin_db = await ensure_user_row(
s, User(user_id="admin-sub", email="[email protected]", name="A", provider="google")
)
user_db = await ensure_user_row(
s, User(user_id="user-sub", email="[email protected]", name="U", provider="google")
)
# Promote a fresh user to "developer" by replacing its default role.
dev_db = await ensure_user_row(
s, User(user_id="dev-sub", email="[email protected]", name="D", provider="google")
)
role_repo = RoleRepo(s)
user_role = await role_repo.get_by_name("user")
admin_role = await role_repo.get_by_name("admin")
dev_role = await role_repo.get_by_name("developer")
viewer_role = await role_repo.get_by_name("viewer")
# Promote the admin persona from its default "user" role to "admin".
await role_repo.revoke_role(admin_db.id, user_role.id)
await role_repo.assign_role(admin_db.id, admin_role.id)
await role_repo.revoke_role(dev_db.id, user_role.id)
await role_repo.assign_role(dev_db.id, dev_role.id)
# And a viewer
viewer_db = await ensure_user_row(
s, User(user_id="viewer-sub", email="[email protected]", name="V", provider="google")
)
await role_repo.revoke_role(viewer_db.id, user_role.id)
await role_repo.assign_role(viewer_db.id, viewer_role.id)
delete_any_db = await ensure_user_row(
s,
User(
user_id="delete-any-sub",
email="[email protected]",
name="Delete Any",
provider="google",
),
)
await role_repo.revoke_role(delete_any_db.id, user_role.id)
delete_any_role = Role(
id="role-delete-any-only",
name="delete-any-only",
description="Legacy unrestricted delete permission only",
)
s.add(delete_any_role)
await s.flush()
delete_any_permission = (
await s.execute(select(Permission).where(Permission.name == "knowledge:delete:any"))
).scalar_one()
s.add(
RolePermission(
role_id=delete_any_role.id,
permission_id=delete_any_permission.id,
)
)
await role_repo.assign_role(delete_any_db.id, delete_any_role.id)
aliased_db = UserRow(
id="db-aliased-user",
oauth_provider="google",
oauth_subject="oauth-aliased-sub",
email="[email protected]",
display_name="Alias",
)
s.add(aliased_db)
await s.flush()
await role_repo.assign_role(aliased_db.id, user_role.id)
await s.commit()
# Map persona name -> User dataclass with id matching the DB row id so
# require_permission's lookups via rbac.get_user_permissions(user.user_id)
# resolve correctly. Note: User.user_id is the *DB id* here so the key
# lookups (which use db_user.id) line up.
PERSONAS["admin"] = User(user_id=admin_db.id, email="[email protected]", name="A", provider="google")
PERSONAS["user"] = User(user_id=user_db.id, email="[email protected]", name="U", provider="google")
PERSONAS["developer"] = User(
user_id=dev_db.id, email="[email protected]", name="D", provider="google"
)
PERSONAS["viewer"] = User(
user_id=viewer_db.id, email="[email protected]", name="V", provider="google"
)
PERSONAS["delete_any"] = User(
user_id=delete_any_db.id,
email="[email protected]",
name="Delete Any",
provider="google",
)
PERSONAS["aliased"] = User(
user_id="oauth-aliased-sub",
email="[email protected]",
name="Alias",
provider="google",
)
_ENSURED_USER_IDS[_user_cache_key(PERSONAS["aliased"])] = aliased_db.id
rbac = RBACService(SessionLocal)
app = FastAPI()
async def _stub_user(request: Request) -> User:
persona = request.headers.get("X-Test-Persona", "user")
return PERSONAS[persona]
app.dependency_overrides[get_current_user] = _stub_user
app.dependency_overrides[get_rbac_service] = lambda: rbac
@app.post("/test/config-write")
async def write_config(user=Depends(require_permission("config:write"))):
return JSONResponse({"user_id": user.user_id})
@app.post("/test/chat-use")
async def use_chat(user=Depends(require_permission("chat:use"))):
return JSONResponse({"user_id": user.user_id})
@app.post("/test/kf-create")
async def kf_create(user=Depends(require_permission("kf:create"))):
return JSONResponse({"user_id": user.user_id})
@app.post("/test/users-list")
async def users_list(user=Depends(require_permission("users:list"))):
return JSONResponse({"user_id": user.user_id})
@app.post("/test/flows-edit")
async def flows_edit(user=Depends(require_permission("flows:edit"))):
return JSONResponse({"user_id": user.user_id})
@app.post("/test/upload-context")
async def upload_context_gate(
user=Depends(require_all_permissions(("knowledge:upload", "chat:use"))),
):
return JSONResponse({"user_id": user.user_id})
@app.post("/test/delete-document")
async def delete_document_gate(
user=Depends(require_document_delete_permission),
):
return JSONResponse({"user_id": user.user_id})
from api.files import list_files as real_list_files
from api.files import search_files as real_search_files
from api.files import upload_histogram as real_upload_histogram
from dependencies import get_file_service_v2
class _Histogram:
async def upload_histogram(self, **_kwargs):
return {"total": 0, "days": {}}
async def list_files(self, **_kwargs):
return {"files": [], "total": 0}
async def search_files(self, **_kwargs):
return {"files": [], "total": 0}
app.add_api_route("/test/real-list-files", real_list_files, methods=["GET"])
app.add_api_route("/test/real-search-files", real_search_files, methods=["GET"])
app.add_api_route("/test/real-upload-histogram", real_upload_histogram, methods=["GET"])
app.dependency_overrides[get_file_service_v2] = lambda: _Histogram()
@app.post("/test/whoami")
async def whoami(user=Depends(require_permission("chat:use"))):
return JSONResponse({"user_id": user.user_id, "db_user_id": user.db_user_id})
yield app
_ENSURED_USER_IDS.pop(_user_cache_key(PERSONAS["aliased"]), None)
await engine.dispose()
@pytest.mark.asyncio
@pytest.mark.parametrize(
"persona, perm_path, expected",
[
# admin → everything passes
("admin", "/test/config-write", 200),
("admin", "/test/chat-use", 200),
("admin", "/test/kf-create", 200),
("admin", "/test/users-list", 200),
("admin", "/test/flows-edit", 200),
# developer → no infra writes, no users:list
("developer", "/test/config-write", 403),
("developer", "/test/chat-use", 200),
("developer", "/test/kf-create", 200),
("developer", "/test/users-list", 403),
("developer", "/test/flows-edit", 200),
# default user → chat + kf:create yes; flows:edit no
("user", "/test/config-write", 403),
("user", "/test/chat-use", 200),
("user", "/test/kf-create", 200),
("user", "/test/users-list", 403),
("user", "/test/flows-edit", 403),
# viewer → chat yes; everything else no
("viewer", "/test/config-write", 403),
("viewer", "/test/chat-use", 200),
("viewer", "/test/kf-create", 403),
("viewer", "/test/users-list", 403),
("viewer", "/test/flows-edit", 403),
# upload-context is both ingestion and chat behavior
("user", "/test/upload-context", 200),
("viewer", "/test/upload-context", 403),
# delete accepts either own or anonymous-document scope
("admin", "/test/delete-document", 200),
("user", "/test/delete-document", 200),
("viewer", "/test/delete-document", 403),
("delete_any", "/test/delete-document", 403),
],
)
async def test_permission_enforcement(app, persona, perm_path, expected):
transport = httpx.ASGITransport(app=app)
async with httpx.AsyncClient(transport=transport, base_url="http://t") as c:
r = await c.post(perm_path, headers={"X-Test-Persona": persona})
assert r.status_code == expected, f"{persona} {perm_path} -> {r.status_code} {r.text}"
if expected == 403:
body = r.json()
assert body["detail"]["error"] == "permission_denied"
@pytest.mark.asyncio
async def test_403_response_includes_required_perm(app):
transport = httpx.ASGITransport(app=app)
async with httpx.AsyncClient(transport=transport, base_url="http://t") as c:
r = await c.post("/test/config-write", headers={"X-Test-Persona": "user"})
assert r.status_code == 403
assert r.json()["detail"]["required"] == "config:write"
@pytest.mark.asyncio
async def test_all_permissions_response_lists_required_permissions(app):
transport = httpx.ASGITransport(app=app)
async with httpx.AsyncClient(transport=transport, base_url="http://t") as c:
r = await c.post("/test/upload-context", headers={"X-Test-Persona": "viewer"})
assert r.status_code == 403
assert r.json()["detail"]["required"] == ["knowledge:upload", "chat:use"]
@pytest.mark.asyncio
async def test_any_permission_response_lists_alternatives(app):
transport = httpx.ASGITransport(app=app)
async with httpx.AsyncClient(transport=transport, base_url="http://t") as c:
r = await c.post("/test/delete-document", headers={"X-Test-Persona": "viewer"})
assert r.status_code == 403
assert r.json()["detail"]["required"] == [
"knowledge:delete:own",
"knowledge:delete:anonymous",
]
@pytest.mark.asyncio
async def test_permission_check_uses_resolved_db_user_id(app):
transport = httpx.ASGITransport(app=app)
async with httpx.AsyncClient(transport=transport, base_url="http://t") as c:
r = await c.post("/test/whoami", headers={"X-Test-Persona": "aliased"})
assert r.status_code == 200
assert r.json() == {
"user_id": "oauth-aliased-sub",
"db_user_id": "db-aliased-user",
}
@pytest.mark.asyncio
@pytest.mark.parametrize(
"persona, expected",
[("admin", 200), ("developer", 200), ("user", 200), ("viewer", 403)],
)
async def test_real_upload_histogram_route_requires_knowledge_read(app, persona, expected):
params = {"start": "2026-10-01T00:00:00Z", "end": "2026-10-31T23:59:59Z"}
transport = httpx.ASGITransport(app=app)
async with httpx.AsyncClient(transport=transport, base_url="http://t") as c:
r = await c.get(
"/test/real-upload-histogram", params=params, headers={"X-Test-Persona": persona}
)
assert r.status_code == expected, f"{persona} -> {r.status_code} {r.text}"
if expected == 403:
assert r.json()["detail"]["error"] == "permission_denied"
@pytest.mark.asyncio
@pytest.mark.parametrize(
"path, params",
[("/test/real-list-files", {}), ("/test/real-search-files", {"q": "x"})],
)
@pytest.mark.parametrize(
"persona, expected",
[("admin", 200), ("developer", 200), ("user", 200), ("viewer", 403)],
)
async def test_real_file_list_routes_require_knowledge_read(app, path, params, persona, expected):
transport = httpx.ASGITransport(app=app)
async with httpx.AsyncClient(transport=transport, base_url="http://t") as c:
r = await c.get(path, params=params, headers={"X-Test-Persona": persona})
assert r.status_code == expected, f"{persona} -> {r.status_code} {r.text}"