Skip to content

armgit / dify

Public Imported from GitHub
0

Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

46.9 KB
Raw Blame
"""
Unit tests for Service API wraps (authentication decorators)
"""

import uuid
from dataclasses import dataclass
from types import SimpleNamespace
from unittest.mock import Mock, patch

import pytest
from flask import Flask
from sqlalchemy import select
from sqlalchemy.orm import Session, scoped_session
from werkzeug.exceptions import Forbidden, NotFound, ServiceUnavailable, Unauthorized

from controllers.common.errors import UnauthorizedError
from controllers.service_api import wraps as wraps_module
from controllers.service_api.wraps import (
    DatasetApiResource,
    FetchUserArg,
    WhereisUserArg,
    cloud_edition_billing_knowledge_limit_check,
    cloud_edition_billing_rate_limit_check,
    cloud_edition_billing_resource_check,
    validate_and_get_api_token,
    validate_app_token,
    validate_dataset_token,
)
from core.db.session_factory import get_session_maker
from enums import CloudPlan, DeploymentEdition
from extensions.application_services.resource_access_token import build_resource_access_token_service
from models import Account, Tenant, TenantAccountJoin
from models.account import TenantAccountRole
from models.dataset import Dataset, RateLimitLog
from models.enums import ApiTokenBindingResourceType, ApiTokenType, EndUserType
from models.knowledge_fs import KnowledgeFSControlSpace, KnowledgeFSControlSpaceState
from models.model import ApiToken, App, AppMode, DatasetApiTokenBinding, EndUser, IconType
from models.resource_access_token import (
    ResourceAccessToken,
    ResourceAccessTokenRelation,
    ResourceAccessTokenResourceType,
)
from services.api_token_service import ApiTokenCache, ApiTokenInvalidError
from services.knowledge_fs.control_space_commands import KnowledgeFSControlSpaceCommandService
from tests.helpers.unit.config_override import config_overrides_context


class _RecordingEndUserCommands:
    def __init__(self, result: EndUser) -> None:
        self._result = result
        self.calls: list[tuple[str, str, str | None]] = []

    def get_or_create_end_user(self, tenant_id: str, app_id: str, user_id: str | None = None) -> EndUser:
        self.calls.append((tenant_id, app_id, user_id))
        return self._result


@dataclass(eq=False, repr=False)
class _AppScopedEndUserServicesStub:
    commands: _RecordingEndUserCommands


class _ApplicationServicesStub:
    def __init__(self, commands: _RecordingEndUserCommands) -> None:
        self.app_scoped_end_users = _AppScopedEndUserServicesStub(commands)


class _RecordingLoginManager:
    def __init__(self) -> None:
        self.users: list[EndUser] = []

    def _update_request_context_with_user(self, user: EndUser) -> None:
        self.users.append(user)


class _RecordingSignal:
    def __init__(self) -> None:
        self.calls: list[tuple[object, EndUser]] = []

    def send(self, sender: object, *, user: EndUser) -> None:
        self.calls.append((sender, user))


def _configure_current_app_mock(mock_current_app):
    mock_current_app.login_manager = Mock()
    mock_current_app._get_current_object = Mock(return_value=Mock())


@pytest.fixture(autouse=True)
def _application_services(monkeypatch: pytest.MonkeyPatch) -> None:
    class FeatureQueries:
        @staticmethod
        def get_workspace_vector_space(workspace_id: str):
            return wraps_module.FeatureService.get_vector_space(workspace_id)

    monkeypatch.setattr(
        wraps_module,
        "application_services",
        lambda: SimpleNamespace(feature_queries=FeatureQueries()),
    )


def _session_proxy(session: Session) -> scoped_session[Session]:
    """Expose the real SQLite session through Flask-SQLAlchemy's callable shape."""
    return scoped_session(lambda: session)


def _api_token(*, tenant_id: str, app_id: str | None = None, token_type: ApiTokenType) -> ApiToken:
    return ApiToken(
        id=str(uuid.uuid4()),
        tenant_id=tenant_id,
        app_id=app_id,
        type=token_type,
        token="test_token",
    )


def _persist_workspace(session: Session) -> tuple[Tenant, Account, TenantAccountJoin]:
    tenant = Tenant(name="Workspace")
    account = Account(name="Owner", email=f"owner-{uuid.uuid4()}@example.com")
    membership = TenantAccountJoin(
        tenant_id=tenant.id,
        account_id=account.id,
        current=True,
        role=TenantAccountRole.OWNER,
    )
    session.add_all([tenant, account, membership])
    session.commit()
    return tenant, account, membership


def _app_model(*, tenant_id: str, enable_api: bool = True) -> App:
    return App(
        id=str(uuid.uuid4()),
        tenant_id=tenant_id,
        name="Service API App",
        mode=AppMode.CHAT,
        icon_type=IconType.EMOJI,
        icon="chat",
        icon_background="#FFFFFF",
        enable_site=False,
        enable_api=enable_api,
    )


class TestValidateAndGetApiToken:
    """Test suite for validate_and_get_api_token function"""

    @pytest.fixture
    def app(self):
        """Create Flask test application."""
        app = Flask(__name__)
        app.config["TESTING"] = True
        return app

    def test_missing_authorization_header(self, app: Flask):
        """Test that Unauthorized is raised when Authorization header is missing."""
        # Arrange
        with app.test_request_context("/", method="GET"):
            # No Authorization header

            # Act & Assert
            with pytest.raises(UnauthorizedError) as exc_info:
                validate_and_get_api_token("app")
            assert "Authorization header must be provided" in str(exc_info.value)

    def test_invalid_auth_scheme(self, app: Flask):
        """Test that Unauthorized is raised when auth scheme is not Bearer."""
        # Arrange
        with app.test_request_context("/", method="GET", headers={"Authorization": "Basic token123"}):
            # Act & Assert
            with pytest.raises(UnauthorizedError) as exc_info:
                validate_and_get_api_token("app")
            assert "Authorization header must be provided and start with 'Bearer'" in str(exc_info.value)

    @patch("controllers.service_api.wraps.record_token_usage")
    @patch("controllers.service_api.wraps.ApiTokenCache")
    @patch("controllers.service_api.wraps.fetch_token_with_single_flight")
    def test_valid_token_returns_api_token(self, mock_fetch_token, mock_cache_cls, mock_record_usage, app: Flask):
        """Test that valid token returns the ApiToken object."""
        # Arrange
        api_token = _api_token(
            tenant_id=str(uuid.uuid4()),
            app_id=str(uuid.uuid4()),
            token_type=ApiTokenType.APP,
        )
        api_token.token = "valid_token_123"

        mock_cache_instance = Mock()
        mock_cache_instance.get.return_value = None  # Cache miss
        mock_cache_cls.get = mock_cache_instance.get
        mock_fetch_token.return_value = api_token

        # Act
        with app.test_request_context("/", method="GET", headers={"Authorization": "Bearer valid_token_123"}):
            result = validate_and_get_api_token("app")

        # Assert
        assert result == api_token

    @patch("controllers.service_api.wraps.record_token_usage")
    @patch("controllers.service_api.wraps.ApiTokenCache")
    @patch("controllers.service_api.wraps.fetch_token_with_single_flight")
    def test_invalid_token_raises_unauthorized(self, mock_fetch_token, mock_cache_cls, mock_record_usage, app: Flask):
        """Test that invalid token raises Unauthorized."""
        # Arrange
        mock_cache_instance = Mock()
        mock_cache_instance.get.return_value = None  # Cache miss
        mock_cache_cls.get = mock_cache_instance.get
        mock_fetch_token.side_effect = ApiTokenInvalidError("Access token is invalid")

        # Act & Assert
        with app.test_request_context("/", method="GET", headers={"Authorization": "Bearer invalid_token"}):
            with pytest.raises(UnauthorizedError) as exc_info:
                validate_and_get_api_token("app")
            assert "Access token is invalid" in str(exc_info.value)


class TestValidateAppToken:
    """Test suite for validate_app_token decorator"""

    @pytest.fixture
    def app(self):
        """Create Flask test application."""
        app = Flask(__name__)
        app.config["TESTING"] = True
        return app

    @pytest.mark.parametrize("separator", ["\u00a0", "\u001c", "\u000b", "\u2003"])
    def test_non_http_whitespace_never_resolves_resource_token(self, app: Flask, separator: str) -> None:
        with (
            app.test_request_context("/", headers={"Authorization": f"Bearer{separator}dify_rt_token"}),
            patch.object(wraps_module, "application_services") as services,
            pytest.raises(UnauthorizedError),
        ):
            validate_app_token(lambda: "ok")()
        services.assert_not_called()

    @patch("controllers.service_api.wraps.user_logged_in")
    @patch("controllers.service_api.wraps.validate_and_get_api_token")
    @patch("controllers.service_api.wraps.current_app")
    @pytest.mark.parametrize(
        "sqlite_session",
        [(App, ApiToken, Tenant, Account, TenantAccountJoin)],
        indirect=True,
    )
    def test_valid_app_token_allows_access(
        self,
        mock_current_app,
        mock_validate_token,
        mock_user_logged_in,
        app: Flask,
        sqlite_session: Session,
    ):
        """Test that valid app token allows access to decorated view."""
        # Arrange
        _configure_current_app_mock(mock_current_app)

        tenant, account, _ = _persist_workspace(sqlite_session)
        app_model = _app_model(tenant_id=tenant.id)
        api_token = _api_token(tenant_id=tenant.id, app_id=app_model.id, token_type=ApiTokenType.APP)
        sqlite_session.add_all([app_model, api_token])
        sqlite_session.commit()
        mock_validate_token.return_value = api_token

        @validate_app_token
        def protected_view(app_model):
            return {"success": True, "app_id": app_model.id}

        # Act
        with (
            app.test_request_context("/", method="GET", headers={"Authorization": "Bearer test_token"}),
            patch("controllers.service_api.wraps.db.session", _session_proxy(sqlite_session)),
        ):
            result = protected_view()

        # Assert
        assert result["success"] is True
        assert result["app_id"] == app_model.id
        assert account.current_tenant_id == tenant.id

    @pytest.mark.parametrize(
        ("fetch_from", "method", "path", "request_kwargs", "expected_user_id"),
        [
            pytest.param(WhereisUserArg.QUERY, "GET", "/?user=query-user", {}, "query-user", id="query"),
            pytest.param(
                WhereisUserArg.JSON,
                "POST",
                "/",
                {"json": {"user": "json-user"}},
                "json-user",
                id="json",
            ),
            pytest.param(
                WhereisUserArg.FORM,
                "POST",
                "/",
                {"data": {"user": "form-user"}},
                "form-user",
                id="form",
            ),
        ],
    )
    @patch("controllers.service_api.wraps.validate_and_get_api_token")
    @pytest.mark.parametrize("sqlite_session", [(App, Tenant)], indirect=True)
    def test_fetch_user_arg_resolves_and_injects_end_user(
        self,
        mock_validate_token,
        app: Flask,
        sqlite_session: Session,
        monkeypatch: pytest.MonkeyPatch,
        fetch_from: WhereisUserArg,
        method: str,
        path: str,
        request_kwargs: dict[str, object],
        expected_user_id: str,
    ) -> None:
        tenant = Tenant(name="Workspace")
        app_model = _app_model(tenant_id=tenant.id)
        sqlite_session.add_all([tenant, app_model])
        sqlite_session.commit()
        mock_validate_token.return_value = _api_token(
            tenant_id=tenant.id,
            app_id=app_model.id,
            token_type=ApiTokenType.APP,
        )

        end_user = EndUser(
            id=str(uuid.uuid4()),
            tenant_id=tenant.id,
            app_id=app_model.id,
            type=EndUserType.SERVICE_API,
            session_id=expected_user_id,
        )
        commands = _RecordingEndUserCommands(end_user)
        login_manager = _RecordingLoginManager()
        signal = _RecordingSignal()
        app.login_manager = login_manager  # type: ignore[attr-defined]
        monkeypatch.setattr(wraps_module, "application_services", lambda: _ApplicationServicesStub(commands))
        monkeypatch.setattr(wraps_module, "user_logged_in", signal)

        @validate_app_token(fetch_user_arg=FetchUserArg(fetch_from=fetch_from, required=True))
        def protected_view(*, app_model: App, end_user: EndUser) -> tuple[App, EndUser]:
            return app_model, end_user

        with (
            app.test_request_context(path, method=method, **request_kwargs),
            patch("controllers.service_api.wraps.db.session", _session_proxy(sqlite_session)),
        ):
            injected_app, injected_end_user = protected_view()

        assert injected_app is app_model
        assert injected_end_user is end_user
        assert commands.calls == [(tenant.id, app_model.id, expected_user_id)]
        assert login_manager.users == [end_user]
        assert signal.calls == [(app, end_user)]

    @patch("controllers.service_api.wraps.user_logged_in")
    @patch("controllers.service_api.wraps.current_app")
    @pytest.mark.parametrize(
        "sqlite_session",
        [(App, ResourceAccessToken, ResourceAccessTokenRelation, Tenant, Account, TenantAccountJoin)],
        indirect=True,
    )
    def test_resource_access_token_allows_bound_app(
        self,
        mock_current_app,
        mock_user_logged_in,
        app: Flask,
        sqlite_session: Session,
        monkeypatch: pytest.MonkeyPatch,
    ):
        _configure_current_app_mock(mock_current_app)
        token_service = build_resource_access_token_service(database_client=get_session_maker())
        monkeypatch.setattr(
            wraps_module, "application_services", lambda: SimpleNamespace(resource_access_tokens=token_service)
        )
        tenant, account, _ = _persist_workspace(sqlite_session)
        app_model = _app_model(tenant_id=tenant.id)
        access_token = ResourceAccessToken(
            tenant_id=tenant.id,
            name="Production integration",
            track_id="a" * 32,
            token="sk-00000000-0000-0000-0000-000000000000",
            created_by=account.id,
        )
        sqlite_session.add_all([app_model, access_token])
        sqlite_session.flush()
        sqlite_session.add(
            ResourceAccessTokenRelation(
                token_id=access_token.id,
                resource_type=ResourceAccessTokenResourceType.APP,
                app_id=app_model.id,
                dataset_id=None,
            )
        )
        sqlite_session.commit()

        @validate_app_token
        def protected_view(app_model):
            return {"success": True, "app_id": app_model.id}

        with (
            app.test_request_context(
                "/",
                method="GET",
                headers={"Authorization": f"Bearer {access_token.token}"},
            ),
            patch("controllers.service_api.wraps.db.session", _session_proxy(sqlite_session)),
        ):
            result = protected_view()

        assert result["app_id"] == app_model.id
        sqlite_session.expire_all()
        assert sqlite_session.get(ResourceAccessToken, access_token.id).last_used_at is not None

    @patch("controllers.service_api.wraps.validate_and_get_api_token")
    @pytest.mark.parametrize("sqlite_session", [(App,)], indirect=True)
    def test_app_not_found_raises_forbidden(self, mock_validate_token, app: Flask, sqlite_session: Session):
        """Test that Forbidden is raised when app no longer exists."""
        # Arrange
        api_token = _api_token(
            tenant_id=str(uuid.uuid4()),
            app_id=str(uuid.uuid4()),
            token_type=ApiTokenType.APP,
        )
        mock_validate_token.return_value = api_token

        @validate_app_token
        def protected_view(**kwargs):
            return {"success": True}

        # Act & Assert
        with (
            app.test_request_context("/", method="GET"),
            patch("controllers.service_api.wraps.db.session", _session_proxy(sqlite_session)),
        ):
            with pytest.raises(Forbidden) as exc_info:
                protected_view()
            assert "no longer exists" in str(exc_info.value)

    @patch("controllers.service_api.wraps.validate_and_get_api_token")
    @pytest.mark.parametrize("sqlite_session", [(App,)], indirect=True)
    def test_app_status_abnormal_raises_forbidden(self, mock_validate_token, app: Flask, sqlite_session: Session):
        """Test that Forbidden is raised when app status is abnormal."""
        # Arrange
        app_model = _app_model(tenant_id=str(uuid.uuid4()))
        sqlite_session.add(app_model)
        sqlite_session.commit()
        app_model.status = "abnormal"
        mock_validate_token.return_value = _api_token(
            tenant_id=app_model.tenant_id,
            app_id=app_model.id,
            token_type=ApiTokenType.APP,
        )

        @validate_app_token
        def protected_view(**kwargs):
            return {"success": True}

        # Act & Assert
        with (
            app.test_request_context("/", method="GET"),
            patch("controllers.service_api.wraps.db.session", _session_proxy(sqlite_session)),
        ):
            with pytest.raises(Forbidden) as exc_info:
                protected_view()
            assert "status is abnormal" in str(exc_info.value)

    @patch("controllers.service_api.wraps.validate_and_get_api_token")
    @pytest.mark.parametrize("sqlite_session", [(App,)], indirect=True)
    def test_app_api_disabled_raises_forbidden(self, mock_validate_token, app: Flask, sqlite_session: Session):
        """Test that Forbidden is raised when app API is disabled."""
        # Arrange
        app_model = _app_model(tenant_id=str(uuid.uuid4()), enable_api=False)
        sqlite_session.add(app_model)
        sqlite_session.commit()
        mock_validate_token.return_value = _api_token(
            tenant_id=app_model.tenant_id,
            app_id=app_model.id,
            token_type=ApiTokenType.APP,
        )

        @validate_app_token
        def protected_view(**kwargs):
            return {"success": True}

        # Act & Assert
        with (
            app.test_request_context("/", method="GET"),
            patch("controllers.service_api.wraps.db.session", _session_proxy(sqlite_session)),
        ):
            with pytest.raises(Forbidden) as exc_info:
                protected_view()
            assert "API service has been disabled" in str(exc_info.value)


class TestCloudEditionBillingResourceCheck:
    """Test suite for cloud_edition_billing_resource_check decorator"""

    @pytest.fixture
    def app(self):
        """Create Flask test application."""
        app = Flask(__name__)
        app.config["TESTING"] = True
        return app

    @config_overrides_context(DEPLOYMENT_EDITION=DeploymentEdition.CLOUD)
    @patch("controllers.service_api.wraps.validate_and_get_api_token")
    @patch("controllers.service_api.wraps.FeatureService.get_features")
    def test_allows_when_under_limit(self, mock_get_features, mock_validate_token, app: Flask):
        """Test that request is allowed when under resource limit."""
        # Arrange
        mock_validate_token.return_value = Mock(tenant_id="tenant123")

        mock_features = Mock()
        mock_features.members.limit = 10
        mock_features.members.size = 5
        mock_get_features.return_value = mock_features

        @cloud_edition_billing_resource_check("members", "app")
        def add_member():
            return "member_added"

        # Act
        with app.test_request_context("/", method="GET"):
            result = add_member()

        # Assert
        assert result == "member_added"
        mock_get_features.assert_called_once_with("tenant123", exclude_vector_space=True)

    @patch("controllers.service_api.wraps.validate_and_get_api_token")
    @patch("controllers.service_api.wraps.FeatureService.get_features")
    @patch("controllers.service_api.wraps.FeatureService.get_vector_space")
    def test_loads_vector_space_from_dedicated_quota_api(
        self, mock_get_vector_space, mock_get_features, mock_validate_token, app: Flask
    ):
        """Test vector-space resource checks avoid loading the full feature payload."""
        # Arrange
        mock_validate_token.return_value = Mock(tenant_id="tenant123")

        mock_vector_space = Mock()
        mock_vector_space.limit = 10
        mock_vector_space.size = 5
        mock_vector_space.usage_unknown = False
        mock_get_vector_space.return_value = mock_vector_space

        @cloud_edition_billing_resource_check("vector_space", "dataset")
        def add_segment():
            return "segment_added"

        # Act
        with (
            app.test_request_context("/", method="GET"),
            config_overrides_context(DEPLOYMENT_EDITION=DeploymentEdition.CLOUD),
        ):
            result = add_segment()

        # Assert
        assert result == "segment_added"
        mock_get_vector_space.assert_called_once_with("tenant123")
        mock_get_features.assert_not_called()

    @patch("controllers.service_api.wraps.validate_and_get_api_token")
    @patch("controllers.service_api.wraps.FeatureService.get_features")
    @patch("controllers.service_api.wraps.FeatureService.get_vector_space")
    def test_rejects_sandbox_when_vector_space_usage_is_unknown(
        self, mock_get_vector_space, mock_get_features, mock_validate_token, app: Flask
    ):
        mock_validate_token.return_value = Mock(tenant_id="tenant123")
        mock_get_vector_space.return_value = Mock(size=0, limit=50, usage_unknown=True)
        mock_get_features.return_value = SimpleNamespace(
            billing=SimpleNamespace(
                subscription=SimpleNamespace(plan=CloudPlan.SANDBOX),
            )
        )

        @cloud_edition_billing_resource_check("vector_space", "dataset")
        def upload_document():
            return "document_uploaded"

        with (
            app.test_request_context("/", method="GET"),
            config_overrides_context(DEPLOYMENT_EDITION=DeploymentEdition.CLOUD),
            pytest.raises(ServiceUnavailable) as exc_info,
        ):
            upload_document()

        assert "Please try again later" in str(exc_info.value)
        mock_get_features.assert_called_once_with("tenant123", exclude_vector_space=True)

    @patch("controllers.service_api.wraps.validate_and_get_api_token")
    @patch("controllers.service_api.wraps.FeatureService.get_features")
    @patch("controllers.service_api.wraps.FeatureService.get_vector_space")
    @pytest.mark.parametrize("plan", [CloudPlan.PROFESSIONAL, CloudPlan.TEAM])
    def test_allows_paid_plan_when_vector_space_usage_is_unknown(
        self, mock_get_vector_space, mock_get_features, mock_validate_token, app: Flask, plan: CloudPlan
    ):
        mock_validate_token.return_value = Mock(tenant_id="tenant123")
        mock_get_vector_space.return_value = Mock(size=0, limit=50, usage_unknown=True)
        mock_get_features.return_value = SimpleNamespace(
            billing=SimpleNamespace(
                subscription=SimpleNamespace(plan=plan),
            )
        )

        @cloud_edition_billing_resource_check("vector_space", "dataset")
        def upload_document():
            return "document_uploaded"

        with (
            app.test_request_context("/", method="GET"),
            config_overrides_context(DEPLOYMENT_EDITION=DeploymentEdition.CLOUD),
        ):
            result = upload_document()

        assert result == "document_uploaded"
        mock_get_features.assert_called_once_with("tenant123", exclude_vector_space=True)

    @config_overrides_context(DEPLOYMENT_EDITION=DeploymentEdition.CLOUD)
    @patch("controllers.service_api.wraps.validate_and_get_api_token")
    @patch("controllers.service_api.wraps.FeatureService.get_features")
    def test_loads_features_when_checking_non_vector_space_limit(
        self, mock_get_features, mock_validate_token, app: Flask
    ):
        """Test non-vector-space resource checks keep using the light feature payload."""
        # Arrange
        mock_validate_token.return_value = Mock(tenant_id="tenant123")

        mock_features = Mock()
        mock_features.documents_upload_quota.limit = 10
        mock_features.documents_upload_quota.size = 5
        mock_get_features.return_value = mock_features

        @cloud_edition_billing_resource_check("documents", "dataset")
        def upload_document():
            return "document_uploaded"

        # Act
        with app.test_request_context("/", method="GET"):
            result = upload_document()

        # Assert
        assert result == "document_uploaded"
        mock_get_features.assert_called_once_with("tenant123", exclude_vector_space=True)

    @config_overrides_context(DEPLOYMENT_EDITION=DeploymentEdition.CLOUD)
    @patch("controllers.service_api.wraps.validate_and_get_api_token")
    @patch("controllers.service_api.wraps.FeatureService.get_features")
    def test_rejects_when_at_limit(self, mock_get_features, mock_validate_token, app: Flask):
        """Test that Forbidden is raised when at resource limit."""
        # Arrange
        mock_validate_token.return_value = Mock(tenant_id="tenant123")

        mock_features = Mock()
        mock_features.members.limit = 10
        mock_features.members.size = 10
        mock_get_features.return_value = mock_features

        @cloud_edition_billing_resource_check("members", "app")
        def add_member():
            return "member_added"

        # Act & Assert
        with app.test_request_context("/", method="GET"):
            with pytest.raises(Forbidden) as exc_info:
                add_member()
            assert "members has reached the limit" in str(exc_info.value)

    @config_overrides_context(DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY)
    @patch("controllers.service_api.wraps.validate_and_get_api_token")
    @patch("controllers.service_api.wraps.FeatureService.get_features")
    def test_allows_when_billing_disabled(self, mock_get_features, mock_validate_token, app: Flask):
        """Test that request is allowed outside Cloud."""
        # Arrange
        mock_validate_token.return_value = Mock(tenant_id="tenant123")

        mock_features = Mock()
        mock_get_features.return_value = mock_features

        @cloud_edition_billing_resource_check("members", "app")
        def add_member():
            return "member_added"

        # Act
        with app.test_request_context("/", method="GET"):
            result = add_member()

        # Assert
        assert result == "member_added"


class TestCloudEditionBillingKnowledgeLimitCheck:
    """Test suite for cloud_edition_billing_knowledge_limit_check decorator"""

    @pytest.fixture
    def app(self):
        """Create Flask test application."""
        app = Flask(__name__)
        app.config["TESTING"] = True
        return app

    @config_overrides_context(DEPLOYMENT_EDITION=DeploymentEdition.CLOUD)
    @patch("controllers.service_api.wraps.validate_and_get_api_token")
    @patch("controllers.service_api.wraps.FeatureService.get_features")
    def test_rejects_add_segment_in_sandbox(self, mock_get_features, mock_validate_token, app: Flask):
        """Test that add_segment is rejected in SANDBOX plan."""
        # Arrange
        mock_validate_token.return_value = Mock(tenant_id="tenant123")

        mock_features = Mock()
        mock_features.billing.subscription.plan = CloudPlan.SANDBOX
        mock_get_features.return_value = mock_features

        @cloud_edition_billing_knowledge_limit_check("add_segment", "dataset")
        def add_segment():
            return "segment_added"

        # Act & Assert
        with app.test_request_context("/", method="GET"):
            with pytest.raises(Forbidden) as exc_info:
                add_segment()
            assert "upgrade to a paid plan" in str(exc_info.value)

    @config_overrides_context(DEPLOYMENT_EDITION=DeploymentEdition.CLOUD)
    @patch("controllers.service_api.wraps.validate_and_get_api_token")
    @patch("controllers.service_api.wraps.FeatureService.get_features")
    def test_allows_other_operations_in_sandbox(self, mock_get_features, mock_validate_token, app: Flask):
        """Test that non-add_segment operations are allowed in SANDBOX."""
        # Arrange
        mock_validate_token.return_value = Mock(tenant_id="tenant123")

        mock_features = Mock()
        mock_features.billing.subscription.plan = CloudPlan.SANDBOX
        mock_get_features.return_value = mock_features

        @cloud_edition_billing_knowledge_limit_check("search", "dataset")
        def search():
            return "search_results"

        # Act
        with app.test_request_context("/", method="GET"):
            result = search()

        # Assert
        assert result == "search_results"


class TestCloudEditionBillingRateLimitCheck:
    """Test suite for cloud_edition_billing_rate_limit_check decorator"""

    @pytest.fixture
    def app(self):
        """Create Flask test application."""
        app = Flask(__name__)
        app.config["TESTING"] = True
        return app

    @patch("controllers.service_api.wraps.validate_and_get_api_token")
    @patch("services.knowledge_rate_limit_service.FeatureService.get_knowledge_rate_limit")
    def test_allows_within_rate_limit(self, mock_get_rate_limit, mock_validate_token, app: Flask):
        """Test that request is allowed when within rate limit."""
        # Arrange
        mock_validate_token.return_value = Mock(tenant_id="tenant123")

        mock_rate_limit = Mock()
        mock_rate_limit.enabled = True
        mock_rate_limit.limit = 100
        mock_get_rate_limit.return_value = mock_rate_limit

        # Mock redis operations
        with patch("services.knowledge_rate_limit_service.redis_client") as mock_redis:
            mock_redis.zcard.return_value = 50  # Under limit

            @cloud_edition_billing_rate_limit_check("knowledge", "dataset")
            def knowledge_request():
                return "success"

            # Act
            with app.test_request_context("/", method="GET"):
                result = knowledge_request()

            # Assert
            assert result == "success"
            mock_redis.zadd.assert_called_once()
            mock_redis.zremrangebyscore.assert_called_once()

    @patch("controllers.service_api.wraps.validate_and_get_api_token")
    @patch("services.knowledge_rate_limit_service.FeatureService.get_knowledge_rate_limit")
    @pytest.mark.parametrize("sqlite_session", [(RateLimitLog,)], indirect=True)
    def test_rejects_over_rate_limit(
        self,
        mock_get_rate_limit,
        mock_validate_token,
        app: Flask,
        sqlite_session: Session,
    ):
        """Test that Forbidden is raised when over rate limit."""
        # Arrange
        tenant_id = str(uuid.uuid4())
        mock_validate_token.return_value = _api_token(
            tenant_id=tenant_id,
            token_type=ApiTokenType.DATASET,
        )

        mock_rate_limit = Mock()
        mock_rate_limit.enabled = True
        mock_rate_limit.limit = 10
        mock_rate_limit.subscription_plan = "pro"
        mock_get_rate_limit.return_value = mock_rate_limit

        with (
            patch("services.knowledge_rate_limit_service.redis_client") as mock_redis,
            patch(
                "services.knowledge_rate_limit_service.db",
                SimpleNamespace(engine=sqlite_session.get_bind()),
            ),
        ):
            mock_redis.zcard.return_value = 15  # Over limit

            @cloud_edition_billing_rate_limit_check("knowledge", "dataset")
            def knowledge_request():
                return "success"

            # Act & Assert
            with app.test_request_context("/", method="GET"):
                with pytest.raises(Forbidden) as exc_info:
                    knowledge_request()
                assert "rate limit" in str(exc_info.value)

        persisted_logs = sqlite_session.scalars(select(RateLimitLog)).all()
        assert len(persisted_logs) == 1
        assert persisted_logs[0].tenant_id == tenant_id
        assert persisted_logs[0].subscription_plan == "pro"
        assert persisted_logs[0].operation == "knowledge"


class TestValidateDatasetToken:
    """Test suite for validate_dataset_token decorator"""

    @pytest.fixture
    def app(self):
        """Create Flask test application."""
        app = Flask(__name__)
        app.config["TESTING"] = True
        return app

    @patch("controllers.service_api.wraps.user_logged_in")
    @patch("controllers.service_api.wraps.validate_and_get_api_token")
    @patch("controllers.service_api.wraps.current_app")
    @pytest.mark.parametrize(
        "sqlite_session",
        [(Tenant, Account, TenantAccountJoin)],
        indirect=True,
    )
    def test_valid_dataset_token(
        self,
        mock_current_app,
        mock_validate_token,
        mock_user_logged_in,
        app: Flask,
        sqlite_session: Session,
    ):
        """Test that valid dataset token allows access."""
        # Arrange
        _configure_current_app_mock(mock_current_app)

        tenant, account, _ = _persist_workspace(sqlite_session)
        api_token = _api_token(tenant_id=tenant.id, token_type=ApiTokenType.DATASET)
        mock_validate_token.return_value = api_token
        sqlite_session.add(api_token)
        sqlite_session.commit()

        @validate_dataset_token
        def protected_view(tenant_id, dataset_grant=None):
            return {
                "success": True,
                "tenant_id": tenant_id,
                "dataset_grant": dataset_grant,
            }

        # Act
        with (
            app.test_request_context("/", method="GET", headers={"Authorization": "Bearer test_token"}),
            patch("controllers.service_api.wraps.db.session", _session_proxy(sqlite_session)),
        ):
            result = protected_view()

        # Assert
        assert result["success"] is True
        assert result["tenant_id"] == tenant.id
        assert result["dataset_grant"].tenant_id == tenant.id
        assert result["dataset_grant"].dataset_ids is None
        assert account.current_tenant_id == tenant.id

    @patch("controllers.service_api.wraps.user_logged_in")
    @patch("controllers.service_api.wraps.current_app")
    @pytest.mark.parametrize(
        "sqlite_session",
        [(Dataset, ResourceAccessToken, ResourceAccessTokenRelation, Tenant, Account, TenantAccountJoin)],
        indirect=True,
    )
    def test_resource_access_token_allows_bound_dataset(
        self,
        mock_current_app,
        mock_user_logged_in,
        app: Flask,
        sqlite_session: Session,
        monkeypatch: pytest.MonkeyPatch,
    ):
        _configure_current_app_mock(mock_current_app)
        token_service = build_resource_access_token_service(database_client=get_session_maker())
        monkeypatch.setattr(
            wraps_module, "application_services", lambda: SimpleNamespace(resource_access_tokens=token_service)
        )
        tenant, account, _ = _persist_workspace(sqlite_session)
        dataset = Dataset(
            id=str(uuid.uuid4()),
            tenant_id=tenant.id,
            name="Customer Support",
            created_by=account.id,
            enable_api=True,
        )
        access_token = ResourceAccessToken(
            tenant_id=tenant.id,
            name="Production integration",
            track_id="b" * 32,
            token="sk-00000000-0000-0000-0000-000000000001",
            created_by=account.id,
        )
        sqlite_session.add_all([dataset, access_token])
        sqlite_session.flush()
        sqlite_session.add(
            ResourceAccessTokenRelation(
                token_id=access_token.id,
                resource_type=ResourceAccessTokenResourceType.KNOWLEDGE,
                app_id=None,
                dataset_id=dataset.id,
            )
        )
        sqlite_session.commit()

        @validate_dataset_token
        def protected_view(tenant_id, dataset_id=None, dataset_grant=None):
            return {
                "success": True,
                "tenant_id": tenant_id,
                "dataset_id": dataset_id,
                "dataset_grant": dataset_grant,
            }

        with (
            app.test_request_context("/", method="GET", headers={"Authorization": f"Bearer {access_token.token}"}),
            patch("controllers.service_api.wraps.db.session", _session_proxy(sqlite_session)),
        ):
            result = protected_view(dataset_id=dataset.id)

        assert result["tenant_id"] == tenant.id
        assert result["dataset_id"] == dataset.id
        assert result["dataset_grant"].dataset_ids == frozenset({dataset.id})
        sqlite_session.expire_all()
        assert sqlite_session.get(ResourceAccessToken, access_token.id).last_used_at is not None

    @patch("controllers.service_api.wraps.validate_and_get_api_token")
    @pytest.mark.parametrize("sqlite_session", [(Dataset,)], indirect=True)
    def test_dataset_not_found_raises_not_found(self, mock_validate_token, app: Flask, sqlite_session: Session):
        """Test that NotFound is raised when dataset doesn't exist."""
        # Arrange
        api_token = _api_token(tenant_id=str(uuid.uuid4()), token_type=ApiTokenType.DATASET)
        mock_validate_token.return_value = api_token
        sqlite_session.add(api_token)
        sqlite_session.commit()

        @validate_dataset_token
        def protected_view(dataset_id=None, **kwargs):
            return {"success": True}

        # Act & Assert
        with (
            app.test_request_context("/", method="GET"),
            patch("controllers.service_api.wraps.db.session", sqlite_session),
        ):
            with pytest.raises(NotFound) as exc_info:
                protected_view(dataset_id=str(uuid.uuid4()))
            assert "Dataset not found" in str(exc_info.value)

    # Per-knowledge-base scope enforcement (DatasetApiTokenBinding rows):
    #   no rows -> the key reaches every dataset in its tenant (default / back-compat)
    #   N rows  -> the key is restricted to exactly those datasets
    # The "reaches the lookup" tests assert a downstream NotFound (the target dataset is
    # intentionally not persisted), proving the binding gate let the request through rather
    # than raising its own Forbidden.

    @patch("controllers.service_api.wraps.validate_and_get_api_token")
    def test_unbound_key_is_not_scope_restricted(self, mock_validate_token, app: Flask, sqlite_session: Session):
        """A key with no bindings passes the scope gate and proceeds to the dataset lookup."""
        api_token = _api_token(tenant_id=str(uuid.uuid4()), token_type=ApiTokenType.DATASET)
        mock_validate_token.return_value = api_token
        sqlite_session.add(api_token)
        sqlite_session.commit()

        @validate_dataset_token
        def protected_view(**kwargs):
            return {"success": True}

        with (
            app.test_request_context("/", method="GET", headers={"Authorization": "Bearer test_token"}),
            patch("controllers.service_api.wraps.db.session", _session_proxy(sqlite_session)),
        ):
            with pytest.raises(NotFound):
                protected_view(dataset_id=str(uuid.uuid4()))

    @patch("controllers.service_api.wraps.validate_and_get_api_token")
    def test_bound_key_rejects_other_dataset(self, mock_validate_token, app: Flask, sqlite_session: Session):
        """A key bound to one dataset is forbidden from reaching a different dataset."""
        api_token = _api_token(tenant_id=str(uuid.uuid4()), token_type=ApiTokenType.DATASET)
        mock_validate_token.return_value = api_token
        sqlite_session.add(api_token)
        sqlite_session.commit()
        sqlite_session.add(DatasetApiTokenBinding(api_token_id=api_token.id, dataset_id=str(uuid.uuid4())))
        sqlite_session.commit()

        @validate_dataset_token
        def protected_view(**kwargs):
            return {"success": True}

        with (
            app.test_request_context("/", method="GET", headers={"Authorization": "Bearer test_token"}),
            patch("controllers.service_api.wraps.db.session", _session_proxy(sqlite_session)),
        ):
            with pytest.raises(Forbidden) as exc_info:
                protected_view(dataset_id=str(uuid.uuid4()))
            assert "not authorized to access this knowledge base" in str(exc_info.value)

    @patch("controllers.service_api.wraps.validate_and_get_api_token")
    def test_key_bound_only_to_knowledge_space_rejects_legacy_dataset(
        self, mock_validate_token, app: Flask, sqlite_session: Session
    ):
        """KnowledgeFS space bindings restrict the key but never grant legacy dataset access."""
        api_token = _api_token(tenant_id=str(uuid.uuid4()), token_type=ApiTokenType.DATASET)
        mock_validate_token.return_value = api_token
        sqlite_session.add(api_token)
        sqlite_session.commit()
        sqlite_session.add(
            DatasetApiTokenBinding(
                api_token_id=api_token.id,
                resource_type=ApiTokenBindingResourceType.KNOWLEDGE_FS_SPACE,
                control_space_id=str(uuid.uuid4()),
            )
        )
        sqlite_session.commit()

        @validate_dataset_token
        def protected_view(**kwargs):
            return {"success": True}

        with (
            app.test_request_context("/", method="GET", headers={"Authorization": "Bearer test_token"}),
            patch("controllers.service_api.wraps.db.session", _session_proxy(sqlite_session)),
        ):
            with pytest.raises(Forbidden) as exc_info:
                protected_view(dataset_id=str(uuid.uuid4()))
            assert "not authorized to access this knowledge base" in str(exc_info.value)

    @patch("controllers.service_api.wraps.validate_and_get_api_token")
    def test_bound_key_rejects_endpoint_without_dataset_id(
        self, mock_validate_token, app: Flask, sqlite_session: Session
    ):
        """A scoped key cannot call collection endpoints (list/create) that carry no dataset id."""
        api_token = _api_token(tenant_id=str(uuid.uuid4()), token_type=ApiTokenType.DATASET)
        mock_validate_token.return_value = api_token
        sqlite_session.add(api_token)
        sqlite_session.commit()
        sqlite_session.add(DatasetApiTokenBinding(api_token_id=api_token.id, dataset_id=str(uuid.uuid4())))
        sqlite_session.commit()

        @validate_dataset_token
        def protected_view(**kwargs):
            return {"success": True}

        with (
            app.test_request_context("/", method="GET", headers={"Authorization": "Bearer test_token"}),
            patch("controllers.service_api.wraps.db.session", _session_proxy(sqlite_session)),
        ):
            with pytest.raises(Forbidden) as exc_info:
                protected_view()
            assert "not authorized to access this knowledge base" in str(exc_info.value)

    @patch("controllers.service_api.wraps.validate_and_get_api_token")
    def test_bound_key_reaches_allowed_dataset(self, mock_validate_token, app: Flask, sqlite_session: Session):
        """A scoped key targeting one of its bound datasets passes the scope gate."""
        api_token = _api_token(tenant_id=str(uuid.uuid4()), token_type=ApiTokenType.DATASET)
        mock_validate_token.return_value = api_token
        sqlite_session.add(api_token)
        sqlite_session.commit()
        allowed_dataset_id = str(uuid.uuid4())
        sqlite_session.add(DatasetApiTokenBinding(api_token_id=api_token.id, dataset_id=allowed_dataset_id))
        sqlite_session.commit()

        @validate_dataset_token
        def protected_view(**kwargs):
            return {"success": True}

        with (
            app.test_request_context("/", method="GET", headers={"Authorization": "Bearer test_token"}),
            patch("controllers.service_api.wraps.db.session", _session_proxy(sqlite_session)),
        ):
            # The bound dataset is allowed by scope; it is simply not persisted, so the
            # downstream lookup raises NotFound instead of the scope Forbidden.
            with pytest.raises(NotFound):
                protected_view(dataset_id=allowed_dataset_id)


@pytest.mark.parametrize("dataset_id", [None, "00000000-0000-0000-0000-000000000001"])
def test_deleted_space_key_cannot_expand_scope_from_stale_authentication_cache(
    app: Flask, sqlite_session: Session, dataset_id: str | None
) -> None:
    tenant_id = str(uuid.uuid4())
    token = _api_token(tenant_id=tenant_id, token_type=ApiTokenType.DATASET)
    space = KnowledgeFSControlSpace(
        tenant_id=tenant_id,
        owner_account_id=str(uuid.uuid4()),
        provisioning_key=str(uuid.uuid4()),
        knowledge_space_id="remote-space",
        state=KnowledgeFSControlSpaceState.ACTIVE,
    )
    sqlite_session.add_all([token, space])
    sqlite_session.flush()
    sqlite_session.add(
        DatasetApiTokenBinding(
            api_token_id=token.id,
            resource_type=ApiTokenBindingResourceType.KNOWLEDGE_FS_SPACE,
            control_space_id=space.id,
        )
    )
    sqlite_session.commit()
    cached = ApiTokenCache._deserialize_token(ApiTokenCache._serialize_token(token))

    @validate_dataset_token
    def protected_view(tenant_id: str, dataset_id: str | None = None) -> None:
        pytest.fail("A deleted scoped key must never reach the endpoint")

    with (
        app.test_request_context(headers={"Authorization": f"Bearer {token.token}"}),
        patch.object(ApiTokenCache, "get", return_value=cached),
        patch.object(ApiTokenCache, "invalidate_by_tenant", return_value=False),
        patch("controllers.service_api.wraps.db.session", _session_proxy(sqlite_session)),
    ):
        with pytest.raises(Forbidden):
            protected_view(dataset_id=dataset_id)
        sqlite_session.rollback()
        KnowledgeFSControlSpaceCommandService(get_session_maker()).request_deletion(
            tenant_id=tenant_id,
            control_space_id=space.id,
            operation_id="delete-space",
            idempotency_key="delete-space",
        )
        with pytest.raises(Unauthorized, match="no longer valid"):
            protected_view(dataset_id=dataset_id)


class TestFetchUserArg:
    """Test suite for FetchUserArg model"""

    def test_fetch_user_arg_defaults(self):
        """Test FetchUserArg default values."""
        # Arrange & Act
        arg = FetchUserArg(fetch_from=WhereisUserArg.JSON)

        # Assert
        assert arg.fetch_from == WhereisUserArg.JSON
        assert arg.required is False

    def test_fetch_user_arg_required(self):
        """Test FetchUserArg with required=True."""
        # Arrange & Act
        arg = FetchUserArg(fetch_from=WhereisUserArg.QUERY, required=True)

        # Assert
        assert arg.fetch_from == WhereisUserArg.QUERY
        assert arg.required is True


class TestDatasetApiResource:
    """Test suite for DatasetApiResource base class"""

    def test_method_decorators_has_validate_dataset_token(self):
        """Test that DatasetApiResource has validate_dataset_token in method_decorators."""
        # Assert
        assert validate_dataset_token in DatasetApiResource.method_decorators

    def test_get_dataset_method_exists(self):
        """Test that get_dataset method exists on DatasetApiResource."""
        # Assert
        assert hasattr(DatasetApiResource, "get_dataset")