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.

refactor(api): enable strict typing for easy UI app config manager tests (#44244)

Eddy ZHANG7c7f93bd530c
diff --git a/api/tests/unit_tests/core/app/app_config/easy_ui_based_app/test_agent_manager.py b/api/tests/unit_tests/core/app/app_config/easy_ui_based_app/test_agent_manager.py
index 359b04070bb..a34c15027a0 100644
--- a/api/tests/unit_tests/core/app/app_config/easy_ui_based_app/test_agent_manager.py
+++ b/api/tests/unit_tests/core/app/app_config/easy_ui_based_app/test_agent_manager.py
@@ -1,19 +1,27 @@
+from collections.abc import Mapping
+from typing import cast
from unittest.mock import MagicMock
import pytest
from pytest_mock import MockerFixture
from core.app.app_config.easy_ui_based_app.agent.manager import AgentConfigManager
+from models.model import AppModelConfigDict
+
+
+def _app_model_config(config: Mapping[str, object]) -> AppModelConfigDict:
+ """App model configs are JSON loaded from the database; these tests build partial ones."""
+ return cast(AppModelConfigDict, config)
class TestAgentConfigManagerConvert:
@pytest.fixture
- def base_config(self):
+ def base_config(self) -> dict[str, dict[str, object]]:
return {
"agent_mode": {
"enabled": True,
"strategy": "cot",
- "tools": [],
+ "tools": list[object](),
},
"model": {
"provider": "openai",
@@ -22,19 +30,20 @@ class TestAgentConfigManagerConvert:
},
}
- def test_convert_returns_none_when_agent_mode_missing(self):
+ def test_convert_returns_none_when_agent_mode_missing(self) -> None:
config = {"model": {"provider": "openai", "name": "gpt-4"}}
- result = AgentConfigManager.convert(config)
+ result = AgentConfigManager.convert(_app_model_config(config))
assert result is None
@pytest.mark.parametrize("agent_mode_value", [None, {}, {"enabled": False}])
- def test_convert_returns_none_when_agent_mode_disabled(self, agent_mode_value, base_config):
- config = base_config.copy()
- config["agent_mode"] = agent_mode_value
+ def test_convert_returns_none_when_agent_mode_disabled(
+ self, agent_mode_value: dict[str, object] | None, base_config: dict[str, dict[str, object]]
+ ) -> None:
+ config = {**base_config, "agent_mode": agent_mode_value}
- result = AgentConfigManager.convert(config)
+ result = AgentConfigManager.convert(_app_model_config(config))
assert result is None
@@ -46,46 +55,56 @@ class TestAgentConfigManagerConvert:
("react", "CHAIN_OF_THOUGHT"),
],
)
- def test_convert_strategy_mapping(self, strategy_input, expected_enum, base_config):
+ def test_convert_strategy_mapping(
+ self, strategy_input: str, expected_enum: str, base_config: dict[str, dict[str, object]]
+ ) -> None:
config = base_config.copy()
config["agent_mode"] = {
"enabled": True,
"strategy": strategy_input,
- "tools": [],
+ "tools": list[object](),
}
- result = AgentConfigManager.convert(config)
+ result = AgentConfigManager.convert(_app_model_config(config))
assert result is not None
assert result.strategy.name == expected_enum
- def test_convert_unknown_strategy_openai_defaults_to_function_calling(self, base_config):
+ def test_convert_unknown_strategy_openai_defaults_to_function_calling(
+ self, base_config: dict[str, dict[str, object]]
+ ) -> None:
config = base_config.copy()
config["agent_mode"] = {
"enabled": True,
"strategy": "unknown_strategy",
- "tools": [],
+ "tools": list[object](),
}
config["model"]["provider"] = "openai"
- result = AgentConfigManager.convert(config)
+ result = AgentConfigManager.convert(_app_model_config(config))
+ assert result is not None
assert result.strategy.name == "FUNCTION_CALLING"
- def test_convert_unknown_strategy_non_openai_defaults_to_chain_of_thought(self, base_config):
+ def test_convert_unknown_strategy_non_openai_defaults_to_chain_of_thought(
+ self, base_config: dict[str, dict[str, object]]
+ ) -> None:
config = base_config.copy()
config["agent_mode"] = {
"enabled": True,
"strategy": "unknown_strategy",
- "tools": [],
+ "tools": list[object](),
}
config["model"]["provider"] = "anthropic"
- result = AgentConfigManager.convert(config)
+ result = AgentConfigManager.convert(_app_model_config(config))
+ assert result is not None
assert result.strategy.name == "CHAIN_OF_THOUGHT"
- def test_convert_skips_disabled_tools(self, mocker: MockerFixture, base_config):
+ def test_convert_skips_disabled_tools(
+ self, mocker: MockerFixture, base_config: dict[str, dict[str, object]]
+ ) -> None:
# Patch AgentEntity to bypass pydantic validation
mock_agent_entity = mocker.patch(
"core.app.app_config.easy_ui_based_app.agent.manager.AgentEntity",
@@ -124,12 +143,14 @@ class TestAgentConfigManagerConvert:
],
}
- AgentConfigManager.convert(config)
+ AgentConfigManager.convert(_app_model_config(config))
mock_validate.assert_called_once()
mock_agent_entity.assert_called_once()
- def test_convert_tool_requires_minimum_keys(self, mocker: MockerFixture, base_config):
+ def test_convert_tool_requires_minimum_keys(
+ self, mocker: MockerFixture, base_config: dict[str, dict[str, object]]
+ ) -> None:
mock_validate = mocker.patch(
"core.app.app_config.easy_ui_based_app.agent.manager.AgentToolEntity.model_validate",
return_value=MagicMock(),
@@ -144,80 +165,84 @@ class TestAgentConfigManagerConvert:
],
}
- result = AgentConfigManager.convert(config)
+ result = AgentConfigManager.convert(_app_model_config(config))
assert result is not None
assert result.tools == []
mock_validate.assert_not_called()
- def test_convert_completion_mode_prompt_defaults(self, base_config):
+ def test_convert_completion_mode_prompt_defaults(self, base_config: dict[str, dict[str, object]]) -> None:
config = base_config.copy()
- config["agent_mode"]["prompt"] = {}
+ config["agent_mode"]["prompt"] = dict[str, object]()
config["model"]["mode"] = "completion"
- result = AgentConfigManager.convert(config)
+ result = AgentConfigManager.convert(_app_model_config(config))
assert result is not None
+ assert result.prompt is not None
assert result.prompt.first_prompt is not None
assert result.prompt.next_iteration is not None
- def test_convert_chat_mode_prompt_defaults(self, base_config):
+ def test_convert_chat_mode_prompt_defaults(self, base_config: dict[str, dict[str, object]]) -> None:
config = base_config.copy()
- config["agent_mode"]["prompt"] = {}
+ config["agent_mode"]["prompt"] = dict[str, object]()
config["model"]["mode"] = "chat"
- result = AgentConfigManager.convert(config)
+ result = AgentConfigManager.convert(_app_model_config(config))
assert result is not None
+ assert result.prompt is not None
assert result.prompt.first_prompt is not None
assert result.prompt.next_iteration is not None
- def test_convert_router_strategy_returns_none(self, base_config):
+ def test_convert_router_strategy_returns_none(self, base_config: dict[str, dict[str, object]]) -> None:
config = base_config.copy()
config["agent_mode"] = {
"enabled": True,
"strategy": "router",
- "tools": [],
+ "tools": list[object](),
}
- result = AgentConfigManager.convert(config)
+ result = AgentConfigManager.convert(_app_model_config(config))
assert result is None
- def test_convert_react_router_strategy_returns_none(self, base_config):
+ def test_convert_react_router_strategy_returns_none(self, base_config: dict[str, dict[str, object]]) -> None:
config = base_config.copy()
config["agent_mode"] = {
"enabled": True,
"strategy": "react_router",
- "tools": [],
+ "tools": list[object](),
}
- result = AgentConfigManager.convert(config)
+ result = AgentConfigManager.convert(_app_model_config(config))
assert result is None
- def test_convert_max_iteration_default(self, base_config):
+ def test_convert_max_iteration_default(self, base_config: dict[str, dict[str, object]]) -> None:
config = base_config.copy()
config["agent_mode"].pop("max_iteration", None)
- result = AgentConfigManager.convert(config)
+ result = AgentConfigManager.convert(_app_model_config(config))
+ assert result is not None
assert result.max_iteration == 10
- def test_convert_custom_max_iteration(self, base_config):
+ def test_convert_custom_max_iteration(self, base_config: dict[str, dict[str, object]]) -> None:
config = base_config.copy()
config["agent_mode"]["max_iteration"] = 25
- result = AgentConfigManager.convert(config)
+ result = AgentConfigManager.convert(_app_model_config(config))
+ assert result is not None
assert result.max_iteration == 25
- def test_convert_missing_model_raises_key_error(self, base_config):
+ def test_convert_missing_model_raises_key_error(self, base_config: dict[str, dict[str, object]]) -> None:
config = base_config.copy()
del config["model"]
with pytest.raises(KeyError):
- AgentConfigManager.convert(config)
+ AgentConfigManager.convert(_app_model_config(config))
@pytest.mark.parametrize(
("invalid_config", "should_raise"),
@@ -228,7 +253,7 @@ class TestAgentConfigManagerConvert:
([], False),
],
)
- def test_convert_invalid_input_type_behavior(self, invalid_config, should_raise):
+ def test_convert_invalid_input_type_behavior(self, invalid_config: object, should_raise: bool) -> None:
if should_raise:
with pytest.raises(TypeError):
AgentConfigManager.convert(invalid_config) # type: ignore
diff --git a/api/tests/unit_tests/core/app/app_config/easy_ui_based_app/test_model_config_manager.py b/api/tests/unit_tests/core/app/app_config/easy_ui_based_app/test_model_config_manager.py
index fe5ba61f317..26b0ead50e9 100644
--- a/api/tests/unit_tests/core/app/app_config/easy_ui_based_app/test_model_config_manager.py
+++ b/api/tests/unit_tests/core/app/app_config/easy_ui_based_app/test_model_config_manager.py
@@ -1,3 +1,5 @@
+from typing import cast
+
import pytest
from pytest_mock import MockerFixture
@@ -9,6 +11,7 @@ from core.plugin.impl.model_runtime_factory import PluginModelAssembly
from graphon.model_runtime.entities.common_entities import I18nObject
from graphon.model_runtime.entities.model_entities import FetchFrom, ModelPropertyKey, ModelType
from graphon.model_runtime.entities.provider_entities import ProviderEntity
+from models.model import AppModelConfigDict
# -----------------------------
# Fixtures
@@ -16,12 +19,12 @@ from graphon.model_runtime.entities.provider_entities import ProviderEntity
@pytest.fixture
-def valid_completion_params():
+def valid_completion_params() -> dict[str, object]:
return {"temperature": 0.7, "stop": ["\n"]}
@pytest.fixture
-def valid_model_list(provider_entities):
+def valid_model_list(provider_entities: list[ProviderEntity]) -> list[ModelWithProviderEntity]:
return [
ModelWithProviderEntity(
model="gpt-4",
@@ -36,7 +39,7 @@ def valid_model_list(provider_entities):
@pytest.fixture
-def provider_entities():
+def provider_entities() -> list[ProviderEntity]:
return [
ProviderEntity(
provider="langgenius/openai/openai",
@@ -48,14 +51,17 @@ def provider_entities():
@pytest.fixture
-def valid_config():
- return {
- "model": {
- "provider": "langgenius/openai/openai",
- "name": "gpt-4",
- "completion_params": {"temperature": 0.5, "stop": ["END"]},
- }
- }
+def valid_config() -> AppModelConfigDict:
+ return cast(
+ AppModelConfigDict,
+ {
+ "model": {
+ "provider": "langgenius/openai/openai",
+ "name": "gpt-4",
+ "completion_params": {"temperature": 0.5, "stop": ["END"]},
+ }
+ },
+ )
# -----------------------------
@@ -65,24 +71,28 @@ def valid_config():
class TestModelConfigManager:
@staticmethod
- def _patch_model_assembly(mocker, *, provider_entities, model_list):
+ def _patch_model_assembly(
+ mocker: MockerFixture, *, provider_entities: list[ProviderEntity], model_list: list[ModelWithProviderEntity]
+ ) -> PluginModelAssembly:
assembly = PluginModelAssembly(tenant_id="tenant1")
configurations = ProviderConfigurations(tenant_id="tenant1")
- def get_providers():
+ def get_providers() -> list[ProviderEntity]:
return provider_entities
- def get_configurations(tenant_id):
+ def get_configurations(tenant_id: str) -> ProviderConfigurations:
assert tenant_id == assembly.tenant_id
return configurations
- def get_models(self, *, provider, model_type):
+ def get_models(
+ self: ProviderConfigurations, *, provider: str, model_type: ModelType
+ ) -> list[ModelWithProviderEntity]:
assert self is configurations
assert provider in [entity.provider for entity in provider_entities]
assert model_type == ModelType.LLM
return model_list
- def create_assembly(*, tenant_id):
+ def create_assembly(*, tenant_id: str) -> PluginModelAssembly:
assert tenant_id == assembly.tenant_id
return assembly
@@ -99,7 +109,7 @@ class TestModelConfigManager:
# convert
# ==========================================================
- def test_convert_success(self, valid_config):
+ def test_convert_success(self, valid_config: AppModelConfigDict) -> None:
result = ModelConfigManager.convert(valid_config)
assert result.provider == "langgenius/openai/openai"
@@ -107,11 +117,11 @@ class TestModelConfigManager:
assert result.parameters == {"temperature": 0.5}
assert result.stop == ["END"]
- def test_convert_missing_model(self):
+ def test_convert_missing_model(self) -> None:
with pytest.raises(ValueError, match="model is required"):
- ModelConfigManager.convert({})
+ ModelConfigManager.convert(cast(AppModelConfigDict, {}))
- def test_convert_without_stop(self):
+ def test_convert_without_stop(self) -> None:
config = {
"model": {
"provider": "langgenius/openai/openai",
@@ -119,7 +129,7 @@ class TestModelConfigManager:
"completion_params": {"temperature": 0.9},
}
}
- result = ModelConfigManager.convert(config)
+ result = ModelConfigManager.convert(cast(AppModelConfigDict, config))
assert result.stop == []
assert result.parameters == {"temperature": 0.9}
@@ -131,21 +141,21 @@ class TestModelConfigManager:
"invalid_cp",
[None, "string", 123, []],
)
- def test_validate_model_completion_params_invalid_type(self, invalid_cp):
+ def test_validate_model_completion_params_invalid_type(self, invalid_cp: object) -> None:
with pytest.raises(ValueError, match="must be of object type"):
- ModelConfigManager.validate_model_completion_params(invalid_cp)
+ ModelConfigManager.validate_model_completion_params(invalid_cp) # pyrefly: ignore[bad-argument-type]
- def test_validate_model_completion_params_default_stop(self):
+ def test_validate_model_completion_params_default_stop(self) -> None:
cp = {"temperature": 0.2}
result = ModelConfigManager.validate_model_completion_params(cp)
assert result["stop"] == []
- def test_validate_model_completion_params_invalid_stop_type(self):
+ def test_validate_model_completion_params_invalid_stop_type(self) -> None:
cp = {"stop": "invalid"}
with pytest.raises(ValueError, match="must be of list type"):
ModelConfigManager.validate_model_completion_params(cp)
- def test_validate_model_completion_params_stop_length_exceeded(self):
+ def test_validate_model_completion_params_stop_length_exceeded(self) -> None:
cp = {"stop": [1, 2, 3, 4, 5]}
with pytest.raises(ValueError, match="less than 4"):
ModelConfigManager.validate_model_completion_params(cp)
@@ -155,8 +165,12 @@ class TestModelConfigManager:
# ==========================================================
def test_validate_and_set_defaults_success(
- self, mocker: MockerFixture, valid_config, provider_entities, valid_model_list
- ):
+ self,
+ mocker: MockerFixture,
+ valid_config: AppModelConfigDict,
+ provider_entities: list[ProviderEntity],
+ valid_model_list: list[ModelWithProviderEntity],
+ ) -> None:
self._patch_model_assembly(
mocker,
provider_entities=provider_entities,
@@ -168,46 +182,65 @@ class TestModelConfigManager:
assert updated_config["model"]["mode"] == "chat"
assert keys == ["model"]
- def test_validate_and_set_defaults_missing_model(self):
+ def test_validate_and_set_defaults_missing_model(self) -> None:
with pytest.raises(ValueError, match="model is required"):
ModelConfigManager.validate_and_set_defaults("tenant1", {})
- def test_validate_and_set_defaults_model_not_dict(self):
+ def test_validate_and_set_defaults_model_not_dict(self) -> None:
with pytest.raises(ValueError, match="object type"):
ModelConfigManager.validate_and_set_defaults("tenant1", {"model": "invalid"})
- def test_validate_and_set_defaults_missing_provider(self, mocker: MockerFixture, provider_entities):
- config = {"model": {"name": "gpt-4", "completion_params": {}}}
+ def test_validate_and_set_defaults_missing_provider(
+ self, mocker: MockerFixture, provider_entities: list[ProviderEntity]
+ ) -> None:
+ config = {"model": {"name": "gpt-4", "completion_params": dict[str, object]()}}
self._patch_model_assembly(mocker, provider_entities=provider_entities, model_list=[])
with pytest.raises(ValueError, match="model.provider is required"):
ModelConfigManager.validate_and_set_defaults("tenant1", config)
- def test_validate_and_set_defaults_invalid_provider(self, mocker: MockerFixture, provider_entities):
- config = {"model": {"provider": "invalid/provider", "name": "gpt-4", "completion_params": {}}}
+ def test_validate_and_set_defaults_invalid_provider(
+ self, mocker: MockerFixture, provider_entities: list[ProviderEntity]
+ ) -> None:
+ config = {"model": {"provider": "invalid/provider", "name": "gpt-4", "completion_params": dict[str, object]()}}
self._patch_model_assembly(mocker, provider_entities=provider_entities, model_list=[])
with pytest.raises(ValueError, match="model.provider is required"):
ModelConfigManager.validate_and_set_defaults("tenant1", config)
- def test_validate_and_set_defaults_missing_name(self, mocker: MockerFixture, provider_entities):
- config = {"model": {"provider": "langgenius/openai/openai", "completion_params": {}}}
+ def test_validate_and_set_defaults_missing_name(
+ self, mocker: MockerFixture, provider_entities: list[ProviderEntity]
+ ) -> None:
+ config = {"model": {"provider": "langgenius/openai/openai", "completion_params": dict[str, object]()}}
self._patch_model_assembly(mocker, provider_entities=provider_entities, model_list=[])
with pytest.raises(ValueError, match="model.name is required"):
ModelConfigManager.validate_and_set_defaults("tenant1", config)
- def test_validate_and_set_defaults_empty_models(self, mocker: MockerFixture, provider_entities):
- config = {"model": {"provider": "langgenius/openai/openai", "name": "gpt-4", "completion_params": {}}}
+ def test_validate_and_set_defaults_empty_models(
+ self, mocker: MockerFixture, provider_entities: list[ProviderEntity]
+ ) -> None:
+ config = {
+ "model": {"provider": "langgenius/openai/openai", "name": "gpt-4", "completion_params": dict[str, object]()}
+ }
self._patch_model_assembly(mocker, provider_entities=provider_entities, model_list=[])
with pytest.raises(ValueError, match="must be in the specified model list"):
ModelConfigManager.validate_and_set_defaults("tenant1", config)
def test_validate_and_set_defaults_invalid_model_name(
- self, mocker: MockerFixture, provider_entities, valid_model_list
- ):
- config = {"model": {"provider": "langgenius/openai/openai", "name": "invalid", "completion_params": {}}}
+ self,
+ mocker: MockerFixture,
+ provider_entities: list[ProviderEntity],
+ valid_model_list: list[ModelWithProviderEntity],
+ ) -> None:
+ config = {
+ "model": {
+ "provider": "langgenius/openai/openai",
+ "name": "invalid",
+ "completion_params": dict[str, object](),
+ }
+ }
self._patch_model_assembly(
mocker,
provider_entities=provider_entities,
@@ -218,12 +251,17 @@ class TestModelConfigManager:
ModelConfigManager.validate_and_set_defaults("tenant1", config)
def test_validate_and_set_defaults_default_mode_when_missing(
- self, mocker: MockerFixture, provider_entities, valid_model_list
- ):
+ self,
+ mocker: MockerFixture,
+ provider_entities: list[ProviderEntity],
+ valid_model_list: list[ModelWithProviderEntity],
+ ) -> None:
model = valid_model_list[0]
- model.model_properties = {}
+ model.model_properties = dict[ModelPropertyKey, object]()
- config = {"model": {"provider": "langgenius/openai/openai", "name": "gpt-4", "completion_params": {}}}
+ config = {
+ "model": {"provider": "langgenius/openai/openai", "name": "gpt-4", "completion_params": dict[str, object]()}
+ }
self._patch_model_assembly(mocker, provider_entities=provider_entities, model_list=[model])
updated_config, _ = ModelConfigManager.validate_and_set_defaults("tenant1", config)
@@ -231,8 +269,11 @@ class TestModelConfigManager:
assert updated_config["model"]["mode"] == "completion"
def test_validate_and_set_defaults_missing_completion_params(
- self, mocker: MockerFixture, provider_entities, valid_model_list
- ):
+ self,
+ mocker: MockerFixture,
+ provider_entities: list[ProviderEntity],
+ valid_model_list: list[ModelWithProviderEntity],
+ ) -> None:
config = {"model": {"provider": "langgenius/openai/openai", "name": "gpt-4"}}
self._patch_model_assembly(
mocker,
@@ -244,8 +285,11 @@ class TestModelConfigManager:
ModelConfigManager.validate_and_set_defaults("tenant1", config)
def test_validate_and_set_defaults_provider_without_slash_converted(
- self, mocker: MockerFixture, provider_entities, valid_model_list
- ):
+ self,
+ mocker: MockerFixture,
+ provider_entities: list[ProviderEntity],
+ valid_model_list: list[ModelWithProviderEntity],
+ ) -> None:
"""
Covers branch where provider does not contain '/' and
ModelProviderID conversion is triggered (line 64).
@@ -254,7 +298,7 @@ class TestModelConfigManager:
"model": {
"provider": "openai", # no slash -> triggers conversion
"name": "gpt-4",
- "completion_params": {},
+ "completion_params": dict[str, object](),
}
}
diff --git a/api/tests/unit_tests/pyrefly.toml b/api/tests/unit_tests/pyrefly.toml
index 3cae02945cc..a2729db2ddd 100644
--- a/api/tests/unit_tests/pyrefly.toml
+++ b/api/tests/unit_tests/pyrefly.toml
@@ -161,10 +161,8 @@ project-excludes = [
"core/agent/test_fc_agent_runner.py",
"core/agent/test_plugin_entities.py",
"core/app/app_config/common/test_sensitive_word_avoidance_manager.py",
- "core/app/app_config/easy_ui_based_app/test_agent_manager.py",
"core/app/app_config/easy_ui_based_app/test_dataset_manager.py",
"core/app/app_config/easy_ui_based_app/test_model_config_converter.py",
- "core/app/app_config/easy_ui_based_app/test_model_config_manager.py",
"core/app/app_config/easy_ui_based_app/test_prompt_template_manager.py",
"core/app/app_config/easy_ui_based_app/test_variables_manager.py",
"core/app/app_config/features/file_upload/test_manager.py",