306 lines
9.3 KiB
Python
306 lines
9.3 KiB
Python
from types import SimpleNamespace
|
|
|
|
import pytest
|
|
|
|
from app.api.v1 import settings as settings_api
|
|
from app.api.v1.settings import (
|
|
WebSearchIntegrationUpdate,
|
|
_build_web_search_payload,
|
|
_mask_secret,
|
|
_normalize_web_search_payload,
|
|
_resolve_web_search_api_key,
|
|
)
|
|
from app.services.ai_tools.schemas import WebSearchConfig, WebSearchProviderConfig
|
|
from app.services.ai_tools.web_search import WebSearchClient
|
|
from app.services.credential_guides import generate_credential_guide
|
|
from app.services.location.llm_fallback import (
|
|
collect_llm_location_fallback_candidate,
|
|
collect_location_search_evidence,
|
|
)
|
|
from app.services.location.models import LocationQuery
|
|
|
|
|
|
@pytest.fixture(autouse=True)
|
|
def isolated_web_search_env_files(monkeypatch, tmp_path):
|
|
env_file = tmp_path / ".env"
|
|
monkeypatch.setattr(settings_api, "WEB_SEARCH_ENV_FILES", (env_file,))
|
|
return env_file
|
|
|
|
|
|
def test_normalize_web_search_payload_adds_default_provider():
|
|
payload = _normalize_web_search_payload({})
|
|
|
|
assert payload["default_provider"] == "tavily"
|
|
assert payload["providers"]["tavily"]["base_url"] == "https://api.tavily.com"
|
|
|
|
|
|
def test_web_search_key_prefers_provider_env(isolated_web_search_env_files):
|
|
isolated_web_search_env_files.write_text(
|
|
"TAVILY_API_KEY=tavily-env-key\nWEB_SEARCH_API_KEY=generic-search-key\n",
|
|
encoding="utf-8",
|
|
)
|
|
|
|
value, source = _resolve_web_search_api_key("tavily", {"api_key": ""})
|
|
|
|
assert value == "tavily-env-key"
|
|
assert source == "env_file"
|
|
|
|
|
|
def test_web_search_generic_key_only_applies_to_default_provider(isolated_web_search_env_files):
|
|
isolated_web_search_env_files.write_text(
|
|
"WEB_SEARCH_API_KEY=generic-search-key\n",
|
|
encoding="utf-8",
|
|
)
|
|
|
|
default_value, default_source = _resolve_web_search_api_key("tavily", {"api_key": ""}, "tavily")
|
|
other_value, other_source = _resolve_web_search_api_key("brave", {"api_key": ""}, "tavily")
|
|
|
|
assert default_value == "generic-search-key"
|
|
assert default_source == "env_file"
|
|
assert other_value == ""
|
|
assert other_source == ""
|
|
|
|
|
|
def test_build_web_search_payload_keeps_saved_key_when_preview_submitted():
|
|
current = {
|
|
"web_search": {
|
|
"default_provider": "tavily",
|
|
"providers": {
|
|
"tavily": {
|
|
"provider": "tavily",
|
|
"api_key": "tvly-old-secret",
|
|
},
|
|
},
|
|
}
|
|
}
|
|
update = WebSearchIntegrationUpdate(
|
|
enabled=True,
|
|
provider="tavily",
|
|
base_url="https://api.tavily.com",
|
|
api_key=_mask_secret("tvly-old-secret")["preview"],
|
|
)
|
|
|
|
payload = _build_web_search_payload(current, update)
|
|
|
|
assert payload["enabled"] is True
|
|
assert payload["providers"]["tavily"]["api_key"] == "tvly-old-secret"
|
|
|
|
|
|
def test_build_web_search_payload_saves_provider_without_changing_default():
|
|
current = {
|
|
"web_search": {
|
|
"default_provider": "tavily",
|
|
"providers": {
|
|
"tavily": {
|
|
"provider": "tavily",
|
|
"api_key": "tvly-key",
|
|
},
|
|
"brave": {
|
|
"provider": "brave",
|
|
"api_key": "",
|
|
},
|
|
},
|
|
}
|
|
}
|
|
update = WebSearchIntegrationUpdate(
|
|
enabled=True,
|
|
provider="brave",
|
|
base_url="https://api.search.brave.com/res/v1/web/search",
|
|
api_key="brave-new-key",
|
|
)
|
|
|
|
payload = _build_web_search_payload(current, update)
|
|
|
|
assert payload["default_provider"] == "tavily"
|
|
assert payload["providers"]["brave"]["api_key"] == "brave-new-key"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_tavily_adapter_normalizes_results(monkeypatch):
|
|
config = WebSearchConfig(
|
|
enabled=True,
|
|
default_provider="tavily",
|
|
provider="tavily",
|
|
providers={
|
|
"tavily": WebSearchProviderConfig(
|
|
provider="tavily",
|
|
base_url="https://api.tavily.com",
|
|
api_key="key",
|
|
)
|
|
},
|
|
)
|
|
client = WebSearchClient(config)
|
|
|
|
async def fake_request_json(*args, **kwargs):
|
|
return {
|
|
"query": "Alem.Cloud",
|
|
"results": [
|
|
{
|
|
"title": "Alem.Cloud official",
|
|
"url": "https://example.test/alem",
|
|
"content": "Alem.Cloud is in Astana.",
|
|
"score": 0.9,
|
|
}
|
|
],
|
|
}
|
|
|
|
monkeypatch.setattr(client, "_request_json", fake_request_json)
|
|
|
|
results = await client.search("Alem.Cloud")
|
|
|
|
assert results[0].source_provider == "tavily"
|
|
assert results[0].url == "https://example.test/alem"
|
|
assert "Astana" in results[0].snippet
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_searxng_adapter_allows_empty_api_key(monkeypatch):
|
|
config = WebSearchConfig(
|
|
enabled=True,
|
|
default_provider="searxng",
|
|
provider="searxng",
|
|
providers={
|
|
"searxng": WebSearchProviderConfig(
|
|
provider="searxng",
|
|
base_url="http://localhost:8080",
|
|
api_key="",
|
|
)
|
|
},
|
|
)
|
|
client = WebSearchClient(config)
|
|
|
|
async def fake_request_json(*args, **kwargs):
|
|
return {
|
|
"results": [
|
|
{
|
|
"title": "TAIPEI-1",
|
|
"url": "https://example.test/taipei",
|
|
"content": "TAIPEI-1 is in Taipei.",
|
|
"score": 2,
|
|
"engine": "duckduckgo",
|
|
}
|
|
],
|
|
}
|
|
|
|
monkeypatch.setattr(client, "_request_json", fake_request_json)
|
|
|
|
results = await client.search("TAIPEI-1")
|
|
|
|
assert results[0].source_provider == "searxng"
|
|
assert results[0].metadata["engine"] == "duckduckgo"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_location_search_evidence_returns_failure_on_empty_results(monkeypatch):
|
|
class EmptySearchClient:
|
|
async def search(self, *args, **kwargs):
|
|
return []
|
|
|
|
result = await collect_location_search_evidence(
|
|
web_search_client=EmptySearchClient(),
|
|
query=LocationQuery(name="TAIPEI-1", country="Taiwan"),
|
|
entity_type="compute_center",
|
|
)
|
|
|
|
assert result.evidence == []
|
|
assert "no usable" in result.failure_reason
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_llm_location_fallback_skips_when_search_evidence_empty():
|
|
class ExplodingAIClient:
|
|
async def analyze(self, *_args, **_kwargs):
|
|
raise AssertionError("LLM should not be called without evidence")
|
|
|
|
result = await collect_llm_location_fallback_candidate(
|
|
provider_client=ExplodingAIClient(),
|
|
query=LocationQuery(name="TAIPEI-1", country="Taiwan"),
|
|
entity_type="compute_center",
|
|
search_evidence=[],
|
|
)
|
|
|
|
assert result.candidates == []
|
|
assert "no WebSearch evidence" in result.failure_reason
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_credential_guide_keeps_default_without_search_evidence():
|
|
class EmptySearchClient:
|
|
async def search(self, *args, **kwargs):
|
|
return []
|
|
|
|
class ExplodingAIClient:
|
|
async def analyze(self, *_args, **_kwargs):
|
|
raise AssertionError("AI should not be called without search evidence")
|
|
|
|
async def fake_get_store(_db):
|
|
return None, {}
|
|
|
|
import app.services.credential_guides as credential_guides
|
|
|
|
original = credential_guides._get_guide_store
|
|
credential_guides._get_guide_store = fake_get_store
|
|
try:
|
|
guide = await generate_credential_guide(
|
|
object(),
|
|
"barentswatch",
|
|
ExplodingAIClient(),
|
|
EmptySearchClient(),
|
|
)
|
|
finally:
|
|
credential_guides._get_guide_store = original
|
|
|
|
assert guide["source"] == "default"
|
|
assert guide["verification_status"] == "unverified_no_search_evidence"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_credential_guide_uses_search_evidence(monkeypatch):
|
|
class SearchClient:
|
|
async def search(self, *args, **kwargs):
|
|
from app.services.ai_tools.schemas import SearchEvidence
|
|
|
|
return [
|
|
SearchEvidence(
|
|
title="Official docs",
|
|
url="https://docs.example.test",
|
|
snippet="Create an AIS client.",
|
|
source_provider="tavily",
|
|
)
|
|
]
|
|
|
|
class AIClient:
|
|
async def analyze(self, payload):
|
|
assert payload.context["search_evidence"]
|
|
return SimpleNamespace(content="## Generated\n\nSources included.")
|
|
|
|
saved = {}
|
|
|
|
async def fake_get_store(_db):
|
|
return None, saved
|
|
|
|
async def fake_save(db, provider, title, markdown, **metadata):
|
|
return {
|
|
"provider": provider,
|
|
"title": title,
|
|
"markdown": markdown,
|
|
"source": "ai",
|
|
**metadata,
|
|
}
|
|
|
|
import app.services.credential_guides as credential_guides
|
|
|
|
monkeypatch.setattr(credential_guides, "_get_guide_store", fake_get_store)
|
|
monkeypatch.setattr(credential_guides, "save_credential_guide", fake_save)
|
|
|
|
guide = await generate_credential_guide(
|
|
object(),
|
|
"barentswatch",
|
|
AIClient(),
|
|
SearchClient(),
|
|
)
|
|
|
|
assert guide["source"] == "ai"
|
|
assert guide["verification_status"] == "verified_with_search_evidence"
|
|
assert guide["sources"][0]["url"] == "https://docs.example.test"
|