Files
javis_bot/tests/tools/builtin/test_weather.py
javis-bot 680d4fbdc1 fix(weather): fall back to met.no when the open-meteo forecast does not answer
Live 2026-11-18 the open-meteo forecast timed out three times (geocoding
worked) and every weather question ended in 'service unavailable'. The
forecast now waits 6s instead of 10s and then asks met.no (no key),
mapping its symbol to the WMO code the Korean sentence uses.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 01:59:49 +09:00

644 lines
26 KiB
Python

"""Tests for weather tool."""
import pytest
from unittest.mock import Mock, patch
import requests
from src.jarvis.tools.builtin.weather import (
WeatherTool,
WMO_CODES,
WMO_CODES_KO,
_extract_place_from_user_text,
_romanise_place,
)
from src.jarvis.tools.base import ToolContext
from src.jarvis.tools.types import ToolExecutionResult
class TestWeatherTool:
"""Test weather tool functionality."""
def setup_method(self):
"""Set up test fixtures."""
self.tool = WeatherTool()
self.context = Mock(spec=ToolContext)
self.context.user_print = Mock()
self.context.cfg = Mock()
# Default to empty user text + empty ollama config so the auto-detect
# fallback path short-circuits the LLM-backed place extractor. Tests
# that want to exercise the extractor override these.
self.context.redacted_text = ""
self.context.cfg.ollama_base_url = ""
self.context.cfg.ollama_chat_model = ""
self.context.cfg.tool_router_model = ""
self.context.cfg.intent_judge_model = ""
def test_tool_properties(self):
"""Test tool metadata properties."""
assert self.tool.name == "getWeather"
assert "weather" in self.tool.description.lower()
assert self.tool.inputSchema["type"] == "object"
# Location is optional - uses user's detected location as fallback
assert "location" in self.tool.inputSchema["properties"]
assert self.tool.inputSchema["required"] == []
@patch('requests.get')
def test_run_success(self, mock_get):
"""Test successful weather retrieval with current + forecast data."""
# First call: geocoding
geo_response = Mock()
geo_response.status_code = 200
geo_response.json.return_value = {
"results": [{
"latitude": 51.5074,
"longitude": -0.1278,
"name": "London",
"country": "United Kingdom",
"admin1": "England"
}]
}
geo_response.raise_for_status = Mock()
# Second call: weather (now includes hourly + daily forecast)
weather_response = Mock()
weather_response.status_code = 200
weather_response.json.return_value = {
"current": {
"time": "2026-04-08T14:00",
"temperature_2m": 15.5,
"apparent_temperature": 14.0,
"relative_humidity_2m": 65,
"weather_code": 2,
"wind_speed_10m": 12.0,
"wind_gusts_10m": 20.0
},
"hourly": {
"time": [f"2026-04-08T{h:02d}:00" for h in range(24)],
"temperature_2m": [10 + h * 0.5 for h in range(24)],
"weather_code": [2] * 24,
},
"daily": {
"time": [f"2026-04-{8+d:02d}" for d in range(7)],
"weather_code": [2, 3, 61, 0, 1, 2, 3],
"temperature_2m_max": [16, 14, 12, 17, 18, 15, 13],
"temperature_2m_min": [8, 7, 5, 9, 10, 8, 6],
},
}
weather_response.raise_for_status = Mock()
mock_get.side_effect = [geo_response, weather_response]
args = {"location": "London"}
result = self.tool.run(args, self.context)
assert isinstance(result, ToolExecutionResult)
assert result.success is True
# One ready-to-speak sentence: place, condition, rounded temperature
# and the feels-like temperature when it differs after rounding.
assert "London" in result.reply_text
assert WMO_CODES_KO[2] in result.reply_text
assert str(round(15.5)) in result.reply_text
assert str(round(14.0)) in result.reply_text
self.context.user_print.assert_called()
@patch('src.jarvis.tools.builtin.weather._romanise_place')
@patch('requests.get')
def test_run_non_latin_location_romanises_and_retries(self, mock_get, mock_romanise):
"""A Korean city name Open-Meteo can't geocode is romanised and retried.
Open-Meteo's geocoder only matches Latin spellings, so ``서울`` returns
no results. The tool must romanise to ``Seoul`` and retry rather than
dead-ending with "could not find location" (the failure the Korean-
locked deployment hit on every weather request)."""
mock_romanise.return_value = "Seoul"
geo_empty = Mock()
geo_empty.raise_for_status = Mock()
geo_empty.json.return_value = {} # no "results"
geo_seoul = Mock()
geo_seoul.raise_for_status = Mock()
geo_seoul.json.return_value = {
"results": [{
"latitude": 37.566,
"longitude": 126.9784,
"name": "Seoul",
"country": "South Korea",
"admin1": "Seoul",
}]
}
weather_response = Mock()
weather_response.raise_for_status = Mock()
weather_response.json.return_value = {
"current": {
"time": "2026-06-12T14:00",
"temperature_2m": 24.0,
"apparent_temperature": 25.0,
"relative_humidity_2m": 55,
"weather_code": 0,
"wind_speed_10m": 6.0,
"wind_gusts_10m": 10.0,
},
"hourly": {
"time": [f"2026-06-12T{h:02d}:00" for h in range(24)],
"temperature_2m": [20 + h * 0.2 for h in range(24)],
"weather_code": [0] * 24,
},
"daily": {
"time": [f"2026-06-{12+d:02d}" for d in range(7)],
"weather_code": [0, 1, 2, 3, 1, 0, 2],
"temperature_2m_max": [25, 26, 24, 23, 27, 28, 25],
"temperature_2m_min": [16, 17, 15, 14, 18, 19, 16],
},
}
mock_get.side_effect = [geo_empty, geo_seoul, weather_response]
result = self.tool.run({"location": "서울"}, self.context)
assert result.success is True
assert "Seoul" in result.reply_text
mock_romanise.assert_called_once()
# The romanised name must be what the second geocode actually queried.
assert mock_get.call_args_list[1].kwargs["params"]["name"] == "Seoul"
@patch('requests.get')
def test_run_comma_place_falls_back_to_wider_area(self, mock_get):
"""A "district, city, country" name the geocoder can't match is retried
without its leading parts, so a location taken from the context (e.g.
a detected "Gangnam-gu, Seoul, South Korea") still gets weather."""
known = {
"Seoul, South Korea": {
"latitude": 37.566, "longitude": 126.9784,
"name": "Seoul", "country": "South Korea", "admin1": "Seoul",
},
}
def fake_get(url, params=None, timeout=None):
resp = Mock()
resp.raise_for_status = Mock()
if "geocoding" in url:
place = known.get(params["name"])
resp.json.return_value = {"results": [place]} if place else {}
else:
resp.json.return_value = {
"current": {
"temperature_2m": 12.0, "apparent_temperature": 11.0,
"weather_code": 0,
},
}
return resp
mock_get.side_effect = fake_get
result = self.tool.run({"location": "Gangnam-gu, Seoul, South Korea"}, self.context)
assert result.success is True
assert "Seoul" in result.reply_text
def test_romanise_place_skips_ascii_names(self):
"""ASCII names already geocode, so no LLM round-trip is spent on them."""
cfg = Mock()
cfg.ollama_base_url = "http://x"
cfg.ollama_chat_model = "qwen2.5:3b"
cfg.tool_router_model = ""
cfg.intent_judge_model = ""
assert _romanise_place("Seoul", cfg) is None
@patch('requests.get')
def test_run_location_not_found(self, mock_get):
"""Test weather with unknown location."""
geo_response = Mock()
geo_response.status_code = 200
geo_response.json.return_value = {"results": []} # No results
geo_response.raise_for_status = Mock()
mock_get.return_value = geo_response
args = {"location": "Nonexistent Place XYZ"}
result = self.tool.run(args, self.context)
assert isinstance(result, ToolExecutionResult)
assert result.success is False
assert "could not find" in result.reply_text.lower()
@patch('src.jarvis.tools.builtin.weather.get_location_info')
def test_run_empty_location_uses_fallback(self, mock_location):
"""Test weather with empty location uses user's detected location as fallback."""
# When location detection fails, should return error
mock_location.return_value = {"error": "Location not available"}
args = {"location": ""}
result = self.tool.run(args, self.context)
assert isinstance(result, ToolExecutionResult)
assert result.success is False
assert result.reply_text and any(kw in result.reply_text.lower() for kw in ("location", "city"))
@patch('src.jarvis.tools.builtin.weather.get_location_info')
def test_run_none_location_uses_fallback(self, mock_location):
"""Test weather with location=None uses user's detected location (not geocode 'None')."""
# When location detection fails, should return error - NOT try to geocode "None"
mock_location.return_value = {"error": "Location not available"}
# LLM may pass location: null/None instead of omitting the field
args = {"location": None}
result = self.tool.run(args, self.context)
assert isinstance(result, ToolExecutionResult)
assert result.success is False
# Should use fallback, not geocode the string "None"
assert result.reply_text and any(kw in result.reply_text.lower() for kw in ("location", "city"))
# Verify location detection was called (fallback was attempted)
mock_location.assert_called_once()
@patch('requests.get')
@patch('src.jarvis.tools.builtin.weather.get_location_info')
def test_without_a_place_the_place_set_in_the_settings_is_used(self, mock_location, mock_get):
"""Live 2026-11-16: detection failed on the game PC and "날씨 어때" got "tell me the city";
the place set in the settings (brain.location, default 대한민국) is the answer instead."""
self.context.cfg.location_name = "South Korea"
geo = Mock(raise_for_status=Mock())
geo.json.return_value = {"results": [{"latitude": 36.5, "longitude": 127.75, "name": "South Korea",
"country": "South Korea"}]}
weather = Mock(raise_for_status=Mock())
weather.json.return_value = {"current": {"temperature_2m": 12.0, "apparent_temperature": 12.0,
"weather_code": 0}}
mock_get.side_effect = [geo, weather]
result = self.tool.run({}, self.context)
assert result.success, result.reply_text
assert mock_get.call_args_list[0].kwargs["params"]["name"] == "South Korea"
mock_location.assert_not_called()
# A place the person asked about still wins over the set one.
mock_get.side_effect = [geo, weather]
self.tool.run({"location": "Busan"}, self.context)
assert mock_get.call_args_list[2].kwargs["params"]["name"] == "Busan"
@patch('src.jarvis.tools.builtin.weather.get_location_info')
def test_run_no_args_uses_fallback(self, mock_location):
"""Test weather with no arguments uses user's detected location as fallback."""
# When location detection fails, should return error
mock_location.return_value = {"error": "Location not available"}
result = self.tool.run(None, self.context)
assert isinstance(result, ToolExecutionResult)
assert result.success is False
assert result.reply_text and any(kw in result.reply_text.lower() for kw in ("location", "city"))
@patch('requests.get')
@patch('src.jarvis.tools.builtin.weather.get_location_info')
def test_run_no_location_with_successful_fallback(self, mock_location, mock_get):
"""Test weather with no location but successful user location detection."""
# Mock successful location detection with coordinates (no geocoding needed)
mock_location.return_value = {
"city": "London",
"region": "England",
"country": "United Kingdom",
"latitude": 51.5074,
"longitude": -0.1278
}
# Mock weather response (no geocoding call needed - we use coordinates directly)
weather_response = Mock()
weather_response.status_code = 200
weather_response.json.return_value = {
"current": {
"temperature_2m": 15.5,
"apparent_temperature": 14.0,
"relative_humidity_2m": 65,
"weather_code": 2,
"wind_speed_10m": 12.0,
"wind_gusts_10m": 20.0
}
}
weather_response.raise_for_status = Mock()
mock_get.return_value = weather_response
# Call with no location - should use fallback coordinates directly
result = self.tool.run({}, self.context)
assert isinstance(result, ToolExecutionResult)
assert result.success is True
assert "London" in result.reply_text
# Verify location detection was called
mock_location.assert_called_once()
# Verify only one request (weather, not geocoding)
assert mock_get.call_count == 1
@patch('requests.get')
@patch('src.jarvis.tools.builtin.weather._extract_place_from_user_text')
@patch('src.jarvis.tools.builtin.weather.get_location_info')
def test_auto_detect_fail_falls_back_to_user_text(
self, mock_location, mock_extract, mock_get,
):
"""When auto-detect fails but the user's utterance names a city, the
tool must pull that city from the text and fetch weather for it — not
ask the user to repeat themselves. Regression for the "I need it for
London" → "please tell me which city" ping-pong loop.
"""
mock_location.return_value = {"error": "Location not available"}
mock_extract.return_value = "London"
geo_response = Mock()
geo_response.status_code = 200
geo_response.json.return_value = {
"results": [{
"latitude": 51.5074,
"longitude": -0.1278,
"name": "London",
"country": "United Kingdom",
"admin1": "England",
}]
}
geo_response.raise_for_status = Mock()
weather_response = Mock()
weather_response.status_code = 200
weather_response.json.return_value = {
"current": {
"time": "2026-04-20T14:00",
"temperature_2m": 12.0,
"apparent_temperature": 10.0,
"relative_humidity_2m": 70,
"weather_code": 2,
"wind_speed_10m": 8.0,
"wind_gusts_10m": 12.0,
}
}
weather_response.raise_for_status = Mock()
mock_get.side_effect = [geo_response, weather_response]
self.context.redacted_text = "I need it for London"
# No location in args, auto-detect fails, extractor recovers "London".
result = self.tool.run({}, self.context)
assert result.success is True
assert "London" in result.reply_text
mock_extract.assert_called_once()
# The extractor must have seen the user's utterance, not the args.
called_text = mock_extract.call_args[0][0]
assert "London" in called_text
@patch('src.jarvis.tools.builtin.weather._extract_place_from_user_text')
@patch('src.jarvis.tools.builtin.weather.get_location_info')
def test_auto_detect_fail_and_no_place_in_text_asks_user(
self, mock_location, mock_extract,
):
"""If auto-detect fails AND the user's utterance doesn't name a place,
the tool should still ask for one — extraction is a best-effort
fallback, not a silent guess."""
mock_location.return_value = {"error": "Location not available"}
mock_extract.return_value = None
self.context.redacted_text = "what's the weather"
result = self.tool.run({}, self.context)
assert result.success is False
assert result.reply_text and any(
kw in result.reply_text.lower() for kw in ("location", "city")
)
@patch('requests.get')
def test_when_open_meteo_does_not_answer_met_no_gives_the_weather(self, mock_get):
"""Live 2026-11-18: the open-meteo forecast timed out (geocoding had worked) and the
answer was that the weather service was unavailable."""
geo = Mock(status_code=200, raise_for_status=Mock())
geo.json.return_value = {"results": [{"latitude": 37.57, "longitude": 126.98,
"name": "서울", "country": "대한민국"}]}
met = Mock(status_code=200, raise_for_status=Mock())
met.json.return_value = {"properties": {"timeseries": [{"data": {
"instant": {"details": {"air_temperature": 8.6, "relative_humidity": 96.0,
"wind_speed": 2.2}},
"next_1_hours": {"summary": {"symbol_code": "lightrainshowers_night"}}}}]}}
def get(url, *a, **k):
if "geocoding" in url:
return geo
if "open-meteo" in url:
raise requests.exceptions.Timeout("timed out")
assert "met.no" in url
return met
mock_get.side_effect = get
result = self.tool.run({"location": "서울"}, self.context)
assert result.success is True
assert "서울" in result.reply_text
assert WMO_CODES_KO[80] in result.reply_text
assert str(round(8.6)) in result.reply_text
@patch('requests.get')
def test_when_both_weather_services_fail_the_answer_says_so(self, mock_get):
geo = Mock(status_code=200, raise_for_status=Mock())
geo.json.return_value = {"results": [{"latitude": 37.57, "longitude": 126.98,
"name": "서울", "country": "대한민국"}]}
def get(url, *a, **k):
if "geocoding" in url:
return geo
raise requests.exceptions.Timeout("timed out")
mock_get.side_effect = get
result = self.tool.run({"location": "서울"}, self.context)
assert result.success is False
assert "unavailable" in result.reply_text.lower()
@patch('requests.get')
def test_run_network_timeout(self, mock_get):
"""Test weather with network timeout."""
mock_get.side_effect = requests.exceptions.Timeout("Connection timed out")
args = {"location": "London"}
result = self.tool.run(args, self.context)
assert isinstance(result, ToolExecutionResult)
assert result.success is False
assert "timeout" in result.reply_text.lower() or "taking too long" in result.reply_text.lower()
@patch('requests.get')
def test_run_network_error(self, mock_get):
"""Test weather with network error."""
mock_get.side_effect = requests.exceptions.ConnectionError("Network error")
args = {"location": "London"}
result = self.tool.run(args, self.context)
assert isinstance(result, ToolExecutionResult)
assert result.success is False
assert "unavailable" in result.reply_text.lower()
def test_wmo_codes_coverage(self):
"""Test that WMO codes dictionary has expected entries."""
# Check some key weather codes
assert WMO_CODES[0] == "Clear sky"
assert WMO_CODES[3] == "Overcast"
assert WMO_CODES[61] == "Slight rain"
assert WMO_CODES[95] == "Thunderstorm"
# Ensure there are many codes covered
assert len(WMO_CODES) >= 20
@patch('requests.get')
def test_reply_is_current_conditions_only(self, mock_get):
"""The reply is one sentence about now: the forecast the API returns is
left out so a small model has nothing to ramble over."""
geo_response = Mock()
geo_response.status_code = 200
geo_response.json.return_value = {
"results": [{
"latitude": 41.6938,
"longitude": 44.8015,
"name": "Tbilisi",
"country": "Georgia",
"admin1": "Tbilisi"
}]
}
geo_response.raise_for_status = Mock()
weather_response = Mock()
weather_response.status_code = 200
weather_response.json.return_value = {
"current": {
"time": "2026-04-08T10:00",
"temperature_2m": 12.0,
"apparent_temperature": 10.0,
"relative_humidity_2m": 70,
"weather_code": 61,
"wind_speed_10m": 8.0,
"wind_gusts_10m": 15.0
},
"hourly": {
"time": [f"2026-04-08T{h:02d}:00" for h in range(24)],
"temperature_2m": [8, 8, 7, 7, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 16, 15, 14, 13, 12, 11, 10, 9, 9, 8],
"weather_code": [61] * 12 + [2] * 12,
},
"daily": {
"time": [f"2026-04-{8+d:02d}" for d in range(7)],
"weather_code": [61, 3, 0, 1, 2, 61, 0],
"temperature_2m_max": [16, 18, 20, 19, 17, 14, 21],
"temperature_2m_min": [7, 8, 10, 9, 8, 6, 11],
},
}
weather_response.raise_for_status = Mock()
mock_get.side_effect = [geo_response, weather_response]
result = self.tool.run({"location": "Tbilisi"}, self.context)
assert result.success is True
assert str(round(12.0)) in result.reply_text
assert WMO_CODES_KO[61] in result.reply_text
assert "\n" not in result.reply_text.strip()
assert "15:00" not in result.reply_text
assert "2026-04-09" not in result.reply_text
@patch('requests.get')
def test_temperature_has_no_unit_for_the_model_to_echo(self, mock_get):
"""Only the rounded Celsius number is given, with no °C/°F or
Fahrenheit value a model could read out as "25도 Celsius"."""
geo_response = Mock()
geo_response.status_code = 200
geo_response.json.return_value = {
"results": [{
"latitude": 40.7128,
"longitude": -74.0060,
"name": "New York",
"country": "United States",
"admin1": "New York"
}]
}
geo_response.raise_for_status = Mock()
weather_response = Mock()
weather_response.status_code = 200
weather_response.json.return_value = {
"current": {
"temperature_2m": 20.0, # 68°F
"apparent_temperature": 18.0,
"relative_humidity_2m": 50,
"weather_code": 0,
"wind_speed_10m": 5.0,
"wind_gusts_10m": None
}
}
weather_response.raise_for_status = Mock()
mock_get.side_effect = [geo_response, weather_response]
args = {"location": "New York"}
result = self.tool.run(args, self.context)
assert result.success is True
assert str(round(20.0)) in result.reply_text # Celsius
assert str(round(20.0 * 9 / 5 + 32)) not in result.reply_text # Fahrenheit
assert "°" not in result.reply_text
class TestExtractPlaceFromUserText:
"""Unit tests for the small-model fallback place extractor."""
def _cfg(self):
cfg = Mock()
cfg.ollama_base_url = "http://localhost:11434"
cfg.ollama_chat_model = "gemma4:e2b"
cfg.tool_router_model = ""
cfg.intent_judge_model = ""
cfg.llm_tools_timeout_sec = 8.0
return cfg
def test_empty_text_returns_none(self):
assert _extract_place_from_user_text("", self._cfg()) is None
assert _extract_place_from_user_text(" ", self._cfg()) is None
def test_none_cfg_returns_none(self):
assert _extract_place_from_user_text("weather in London", None) is None
def test_unconfigured_model_returns_none(self):
cfg = Mock()
cfg.ollama_base_url = ""
cfg.ollama_chat_model = ""
cfg.tool_router_model = ""
cfg.intent_judge_model = ""
assert _extract_place_from_user_text("weather in London", cfg) is None
@patch("src.jarvis.tools.builtin.weather.call_llm_direct", create=True)
def test_extracts_clean_place_name(self, _mock_direct):
"""Patch the import inside the function by intercepting call_llm_direct."""
from src.jarvis.llm import call_llm_direct as real_fn # noqa: F401
with patch("src.jarvis.llm.call_llm_direct", return_value="London"):
got = _extract_place_from_user_text("I need it for London", self._cfg())
assert got == "London"
def test_strips_quotes_and_punctuation(self):
with patch("src.jarvis.llm.call_llm_direct", return_value="'Paris'."):
got = _extract_place_from_user_text("weather paris?", self._cfg())
assert got == "Paris"
def test_none_sentinel_returns_none(self):
for sentinel in ("none", "None", "NONE", "n/a", "unknown"):
with patch("src.jarvis.llm.call_llm_direct", return_value=sentinel):
assert _extract_place_from_user_text(
"what's the weather", self._cfg()
) is None
def test_sentence_response_rejected(self):
"""If the model explains instead of answering, treat it as no-place."""
with patch(
"src.jarvis.llm.call_llm_direct",
return_value="The user did not name a place.",
):
got = _extract_place_from_user_text("weather today", self._cfg())
assert got is None
def test_overlong_response_rejected(self):
with patch("src.jarvis.llm.call_llm_direct", return_value="x" * 200):
got = _extract_place_from_user_text("weather", self._cfg())
assert got is None