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.

10.4 KB
Raw Blame
"""Resolve real stored OAuth credentials before entering provider operations."""

from collections.abc import Iterator
from dataclasses import dataclass, field
from tempfile import TemporaryDirectory
from uuid import uuid4

import pytest
from flask import Flask
from sqlalchemy import Connection, Engine, event
from sqlalchemy.orm import Session, SessionTransaction, sessionmaker

from core.entities.provider_entities import ProviderConfig, ProviderConfigType
from core.tools.utils.system_encryption import encrypt_system_params
from extensions.ext_key_provider import key_provider_manager
from extensions.ext_storage import storage
from models.account import Tenant
from models.engine import db
from models.provider_ids import TriggerProviderID
from models.trigger import TriggerOAuthSystemClient, TriggerOAuthTenantClient
from repositories.trigger.oauth_client_repository import TriggerOAuthClientRepository
from services.plugin.dispatch_identity import PluginOAuthClientConfig
from services.trigger.oauth_client_service import (
    TriggerOAuthClientConfigError,
    TriggerOAuthClientService,
    TriggerOAuthProviderMetadata,
)
from tests.helpers.unit.config_override import config_overrides_context

_IDENTIFIER = "langgenius/github:1.0.0@test"
_PROVIDER = TriggerProviderID("langgenius/github/github")
_SCHEMA = [
    ProviderConfig(name="client_id", type=ProviderConfigType.TEXT_INPUT),
    ProviderConfig(name="client_secret", type=ProviderConfigType.SECRET_INPUT),
]


@dataclass
class _PluginMetadata:
    """Only metadata from the plugin daemon is supplied by this external boundary."""

    tenant_id: str
    sessions: list[Session] = field(default_factory=list)
    verified: bool = True
    verification_calls: int = 0

    def assert_sessions_closed(self) -> None:
        assert all(not session.in_transaction() and not session.identity_map for session in self.sessions)

    def get_metadata(self, *, tenant_id: str, provider_id: TriggerProviderID) -> TriggerOAuthProviderMetadata:
        self.assert_sessions_closed()
        assert tenant_id == self.tenant_id
        assert provider_id == _PROVIDER
        return TriggerOAuthProviderMetadata(schema=_SCHEMA, plugin_unique_identifier=_IDENTIFIER)

    def is_verified(self, *, tenant_id: str, plugin_unique_identifier: str) -> bool:
        self.assert_sessions_closed()
        assert tenant_id == self.tenant_id
        assert plugin_unique_identifier == _IDENTIFIER
        self.verification_calls += 1
        return self.verified


@dataclass(frozen=True)
class _Harness:
    service: TriggerOAuthClientService
    session_factory: sessionmaker[Session]
    metadata: _PluginMetadata

    @property
    def tenant_id(self) -> str:
        return self.metadata.tenant_id

    def add_system(self, *, encrypted_params: str) -> None:
        with self.session_factory.begin() as session:
            session.add(
                TriggerOAuthSystemClient(
                    plugin_id=_PROVIDER.plugin_id,
                    provider=_PROVIDER.provider_name,
                    encrypted_oauth_params=encrypted_params,
                )
            )

    def add_custom(self, *, encrypted_params: str, enabled: bool) -> None:
        with self.session_factory.begin() as session:
            session.add(
                TriggerOAuthTenantClient(
                    tenant_id=self.tenant_id,
                    plugin_id=_PROVIDER.plugin_id,
                    provider=_PROVIDER.provider_name,
                    encrypted_oauth_params=encrypted_params,
                    enabled=enabled,
                )
            )

    def resolve(self) -> PluginOAuthClientConfig | None:
        result = self.service.resolve(tenant_id=self.tenant_id, provider_id=_PROVIDER)
        self.metadata.assert_sessions_closed()
        return result


@pytest.fixture
def harness(sqlite_engine: Engine, sqlite_session_factory: sessionmaker[Session]) -> Iterator[_Harness]:
    previous_storage = storage.__dict__.copy()
    previous_key_provider = key_provider_manager._provider
    with (
        TemporaryDirectory(prefix="trigger-oauth-resolution-keys-") as storage_path,
        config_overrides_context(
            KEY_PROVIDER_TYPE="local",
            STORAGE_TYPE="local",
            STORAGE_LOCAL_PATH=storage_path,
        ),
    ):
        app = Flask(__name__)
        app.config.update(TESTING=True, SQLALCHEMY_DATABASE_URI=str(sqlite_engine.url))
        db.init_app(app)
        storage.init_app(app)
        key_provider_manager.init_app(app)
        with sqlite_session_factory.begin() as session:
            tenant = Tenant(name="OAuth workspace")
            session.add(tenant)
            session.flush()
            tenant_id = tenant.id
        metadata = _PluginMetadata(tenant_id)
        service = TriggerOAuthClientService(
            clients=TriggerOAuthClientRepository(session_factory=sqlite_session_factory), providers=metadata
        )

        def observe_repository_session(
            session: Session, _transaction: SessionTransaction, _connection: Connection
        ) -> None:
            metadata.sessions.append(session)

        def assert_repository_closed_for_key_lookup(
            _session: Session, _transaction: SessionTransaction, _connection: Connection
        ) -> None:
            metadata.assert_sessions_closed()

        event.listen(sqlite_session_factory.class_, "after_begin", observe_repository_session)
        event.listen(db.session.session_factory.class_, "after_begin", assert_repository_closed_for_key_lookup)
        try:
            with app.app_context():
                yield _Harness(service, sqlite_session_factory, metadata)
        finally:
            event.remove(sqlite_session_factory.class_, "after_begin", observe_repository_session)
            event.remove(db.session.session_factory.class_, "after_begin", assert_repository_closed_for_key_lookup)
            with app.app_context():
                db.session.remove()
                db.engine.dispose()
            storage.__dict__.clear()
            storage.__dict__.update(previous_storage)
            key_provider_manager._provider = previous_key_provider


def test_resolve_without_configuration_returns_none_without_verification(harness: _Harness) -> None:
    assert harness.resolve() is None
    assert harness.metadata.verification_calls == 0


def test_enabled_custom_credentials_decrypt_with_real_rsa_and_take_priority(harness: _Harness) -> None:
    with harness.session_factory.begin() as session:
        tenant = session.get(Tenant, harness.tenant_id)
        assert tenant is not None
        tenant.encrypt_public_key = key_provider_manager.provider.generate_key_pair(tenant.id)
    harness.add_system(encrypted_params=encrypt_system_params({"client_secret": "system-secret"}))
    harness.metadata.verified = False
    harness.service.save(
        tenant_id=harness.tenant_id,
        provider_id=_PROVIDER,
        client_params={"client_id": "tenant-id", "client_secret": "tenant-secret"},
        enabled=True,
    )

    assert harness.resolve() == PluginOAuthClientConfig(
        _IDENTIFIER, {"client_id": "tenant-id", "client_secret": "tenant-secret"}
    )
    assert harness.metadata.verification_calls == 0


def test_enabled_empty_custom_client_does_not_fall_back_to_system(harness: _Harness) -> None:
    harness.add_custom(encrypted_params="{}", enabled=True)
    harness.add_system(encrypted_params=encrypt_system_params({"client_id": "system-id"}))

    assert harness.resolve() == PluginOAuthClientConfig(_IDENTIFIER, {})
    assert harness.metadata.verification_calls == 0


@pytest.mark.parametrize("custom_enabled", [None, False])
def test_verified_system_credentials_are_used_without_enabled_custom_client(
    harness: _Harness, custom_enabled: bool | None
) -> None:
    if custom_enabled is not None:
        harness.add_custom(encrypted_params="invalid-but-disabled", enabled=custom_enabled)
    harness.add_system(encrypted_params=encrypt_system_params({"client_id": "system-id", "client_secret": "secret"}))

    assert harness.resolve() == PluginOAuthClientConfig(
        _IDENTIFIER, {"client_id": "system-id", "client_secret": "secret"}
    )
    assert harness.metadata.verification_calls == 1


def test_unverified_plugin_cannot_read_system_credentials(harness: _Harness) -> None:
    harness.add_system(encrypted_params="invalid-system-ciphertext")
    harness.metadata.verified = False

    assert harness.resolve() is None
    assert harness.metadata.verification_calls == 1


@pytest.mark.parametrize("invalid_params", ['{"client_secret": "private-value"', '["private-value"]'])
def test_invalid_enabled_custom_config_raises_domain_error_without_exposing_contents(
    harness: _Harness, invalid_params: str
) -> None:
    harness.add_custom(encrypted_params=invalid_params, enabled=True)

    with pytest.raises(TriggerOAuthClientConfigError) as raised:
        harness.resolve()

    assert str(_PROVIDER) in str(raised.value)
    assert "private-value" not in str(raised.value)
    harness.metadata.assert_sessions_closed()


@pytest.mark.parametrize("invalid_params", ["", "invalid-system-ciphertext"])
def test_invalid_system_config_raises_domain_error_without_exposing_ciphertext(
    harness: _Harness, invalid_params: str
) -> None:
    harness.add_system(encrypted_params=invalid_params)

    with pytest.raises(TriggerOAuthClientConfigError) as raised:
        harness.resolve()

    assert "system OAuth client" in str(raised.value)
    assert "invalid-system-ciphertext" not in str(raised.value)
    harness.metadata.assert_sessions_closed()


def test_disabled_custom_without_system_client_returns_none(harness: _Harness) -> None:
    harness.add_custom(encrypted_params="invalid-but-disabled", enabled=False)

    assert harness.resolve() is None
    assert harness.metadata.verification_calls == 0


@pytest.mark.parametrize("other_scope", ["tenant", "plugin", "provider"])
def test_resolution_does_not_read_custom_credentials_from_other_scope(harness: _Harness, other_scope: str) -> None:
    with harness.session_factory.begin() as session:
        session.add(
            TriggerOAuthTenantClient(
                tenant_id=str(uuid4()) if other_scope == "tenant" else harness.tenant_id,
                plugin_id="langgenius/other" if other_scope == "plugin" else _PROVIDER.plugin_id,
                provider="other" if other_scope == "provider" else _PROVIDER.provider_name,
                encrypted_oauth_params='{"client_id": "other-scope"}',
                enabled=True,
            )
        )

    assert harness.resolve() is None