async def test_nws_set_station(aiohttp_client, loop, mock_urls):
app = setup_app()
client = await aiohttp_client(app)
nws = SimpleNWS(*LATLON, USERID, client)
await nws.set_station(STATION)
assert nws.station == STATION
assert nws.stations == [STATION]
async def test_nws_forecast_empty(aiohttp_client, loop, mock_urls):
app = setup_app(gridpoints_forecast="gridpoints_forecast_empty.json")
client = await aiohttp_client(app)
nws = SimpleNWS(*LATLON, USERID, client)
await nws.update_forecast()
forecast = nws.forecast
assert forecast == []
async def test_nws_forecast_hourly(aiohttp_client, loop, mock_urls):
app = setup_app()
client = await aiohttp_client(app)
nws = SimpleNWS(*LATLON, USERID, client)
await nws.update_forecast_hourly()
forecast = nws.forecast_hourly
assert forecast[0]["temperature"] == 78
async def test_nws_observation_metar_noparse(aiohttp_client, loop, mock_urls):
app = setup_app(
stations_observations="stations_observations_metar_noparse.json")
client = await aiohttp_client(app)
nws = SimpleNWS(*LATLON, USERID, client)
await nws.set_station(STATION)
await nws.update_observation()
observation = nws.observation
assert observation["temperature"] is None
def __init__(self, hass, latitude, longitude, api_key, websession):
"""Initialize the data."""
self.hass = hass
self.latitude = latitude
self.longitude = longitude
ha_api_key = f"{api_key} homeassistant"
self.nws = SimpleNWS(latitude, longitude, ha_api_key, websession)
self.update_observation_success = True
self.update_forecast_success = True
self.update_forecast_hourly_success = True
async def test_nws_alerts_all_zones(aiohttp_client, loop, mock_urls):
app = setup_app()
client = await aiohttp_client(app)
nws = SimpleNWS(*LATLON, USERID, client)
new_alerts = await nws.update_alerts_all_zones()
assert len(nws.all_zones) == 2
assert new_alerts
alerts = nws.alerts_all_zones
assert alerts
assert new_alerts == alerts
assert len(alerts) == 1
async def test_nws_observation_units(aiohttp_client, loop, mock_urls):
app = setup_app(
stations_observations="stations_observations_alternate_units.json")
client = await aiohttp_client(app)
nws = SimpleNWS(*LATLON, USERID, client)
await nws.set_station(STATION)
await nws.update_observation()
observation = nws.observation
assert observation
assert round(observation["temperature"], 1) == -12.2
assert observation["windSpeed"] == 10 # converted to km_gr
assert observation["windGust"] == 10
async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry):
"""Set up a National Weather Service entry."""
latitude = entry.data[CONF_LATITUDE]
longitude = entry.data[CONF_LONGITUDE]
api_key = entry.data[CONF_API_KEY]
station = entry.data[CONF_STATION]
client_session = async_get_clientsession(hass)
# set_station only does IO when station is None
nws_data = SimpleNWS(latitude, longitude, api_key, client_session)
await nws_data.set_station(station)
coordinator_observation = DataUpdateCoordinator(
hass,
_LOGGER,
name=f"NWS observation station {station}",
update_method=nws_data.update_observation,
update_interval=DEFAULT_SCAN_INTERVAL,
)
coordinator_forecast = DataUpdateCoordinator(
hass,
_LOGGER,
name=f"NWS forecast station {station}",
update_method=nws_data.update_forecast,
update_interval=DEFAULT_SCAN_INTERVAL,
)
coordinator_forecast_hourly = DataUpdateCoordinator(
hass,
_LOGGER,
name=f"NWS forecast hourly station {station}",
update_method=nws_data.update_forecast_hourly,
update_interval=DEFAULT_SCAN_INTERVAL,
)
nws_hass_data = hass.data.setdefault(DOMAIN, {})
nws_hass_data[entry.entry_id] = {
NWS_DATA: nws_data,
COORDINATOR_OBSERVATION: coordinator_observation,
COORDINATOR_FORECAST: coordinator_forecast,
COORDINATOR_FORECAST_HOURLY: coordinator_forecast_hourly,
}
# Fetch initial data so we have data when entities subscribe
await coordinator_observation.async_refresh()
await coordinator_forecast.async_refresh()
await coordinator_forecast_hourly.async_refresh()
for component in PLATFORMS:
hass.async_create_task(
hass.config_entries.async_forward_entry_setup(entry, component))
return True
async def test_nws_alerts_all_zones_second_alert(aiohttp_client, loop,
mock_urls):
app = setup_app(alerts_active_zone=[
"alerts_active_zone.json", "alerts_active_zone_second.json"
])
client = await aiohttp_client(app)
nws = SimpleNWS(*LATLON, USERID, client)
new_alerts = await nws.update_alerts_all_zones()
assert len(nws.all_zones) == 2
assert new_alerts
alerts = nws.alerts_all_zones
assert alerts
assert new_alerts == alerts
assert len(alerts) == 2
async def test_nws_forecast_strings(aiohttp_client, loop, mock_urls):
app = setup_app(gridpoints_forecast="gridpoints_forecast_strings.json")
client = await aiohttp_client(app)
nws = SimpleNWS(*LATLON, USERID, client)
await nws.update_forecast()
forecast = nws.forecast
assert forecast[0]["iconWeather"][0][
0] == "Thunderstorm (high cloud cover)"
assert forecast[0]["iconWeather"][0][1] == 40
assert forecast[0]["iconWeather"][1][0] == "Overcast"
assert forecast[0]["iconWeather"][1][1] is None
assert forecast[0]["windSpeedAvg"] == 10
assert forecast[0]["windBearing"] == 180
async def test_nws_observation_metar(aiohttp_client, loop, mock_urls):
app = setup_app(stations_observations="stations_observations_metar.json")
client = await aiohttp_client(app)
nws = SimpleNWS(*LATLON, USERID, client)
await nws.set_station(STATION)
await nws.update_observation()
observation = nws.observation
assert observation["temperature"] == 25.6
assert observation["dewpoint"] is None
assert observation["relativeHumidity"] is None
assert observation["windDirection"] == 350.0
assert observation["visibility"] == 16093.44
assert round(observation["seaLevelPressure"]) == 101761
assert round(observation["windSpeed"], 2) == 9.26
assert observation["windGust"] is None
async def test_nws_observation_empty(aiohttp_client, loop, mock_urls):
app = setup_app(stations_observations="stations_observations_empty.json")
client = await aiohttp_client(app)
nws = SimpleNWS(*LATLON, USERID, client)
await nws.set_station(STATION)
await nws.update_observation()
observation = nws.observation
assert observation["temperature"] is None
assert observation["dewpoint"] is None
assert observation["relativeHumidity"] is None
assert observation["windDirection"] is None
assert observation["visibility"] is None
assert observation["seaLevelPressure"] is None
assert observation["windSpeed"] is None
assert observation["windGust"] is None
assert observation["iconTime"] is None
assert observation["iconWeather"] is None
async def validate_input(hass: core.HomeAssistant, data):
"""Validate the user input allows us to connect.
Data has the keys from DATA_SCHEMA with values provided by the user.
"""
latitude = data[CONF_LATITUDE]
longitude = data[CONF_LONGITUDE]
api_key = data[CONF_API_KEY]
station = data.get(CONF_STATION)
client_session = async_get_clientsession(hass)
ha_api_key = f"{api_key} homeassistant"
nws = SimpleNWS(latitude, longitude, ha_api_key, client_session)
try:
await nws.set_station(station)
except aiohttp.ClientError as err:
_LOGGER.error("Could not connect: %s", err)
raise CannotConnect from err
return {"title": nws.station}
async def test_nws_observation(aiohttp_client, loop, mock_urls,
observation_json):
app = setup_app(stations_observations=observation_json)
client = await aiohttp_client(app)
nws = SimpleNWS(*LATLON, USERID, client)
with pytest.raises(NwsError):
await nws.update_observation()
await nws.set_station(STATION)
await nws.update_observation()
observation = nws.observation
assert observation
assert observation["temperature"] == 10
assert observation["dewpoint"] == 10
assert observation["relativeHumidity"] == 10
assert observation["windDirection"] == 10
assert observation["visibility"] == 10000
assert observation["seaLevelPressure"] == 100000
assert observation["windSpeed"] == 36 # converted to km_gr
assert observation["iconTime"] == "day"
assert observation["windGust"] == 36 # same
assert observation["iconWeather"][0][0] == "A few clouds"
assert observation["iconWeather"][0][1] is None
async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
"""Set up a National Weather Service entry."""
latitude = entry.data[CONF_LATITUDE]
longitude = entry.data[CONF_LONGITUDE]
api_key = entry.data[CONF_API_KEY]
station = entry.data[CONF_STATION]
client_session = async_get_clientsession(hass)
# set_station only does IO when station is None
nws_data = SimpleNWS(latitude, longitude, api_key, client_session)
await nws_data.set_station(station)
coordinator_observation = NwsDataUpdateCoordinator(
hass,
_LOGGER,
name=f"NWS observation station {station}",
update_method=nws_data.update_observation,
update_interval=DEFAULT_SCAN_INTERVAL,
failed_update_interval=FAILED_SCAN_INTERVAL,
request_refresh_debouncer=debounce.Debouncer(hass,
_LOGGER,
cooldown=DEBOUNCE_TIME,
immediate=True),
)
coordinator_forecast = NwsDataUpdateCoordinator(
hass,
_LOGGER,
name=f"NWS forecast station {station}",
update_method=nws_data.update_forecast,
update_interval=DEFAULT_SCAN_INTERVAL,
failed_update_interval=FAILED_SCAN_INTERVAL,
request_refresh_debouncer=debounce.Debouncer(hass,
_LOGGER,
cooldown=DEBOUNCE_TIME,
immediate=True),
)
coordinator_forecast_hourly = NwsDataUpdateCoordinator(
hass,
_LOGGER,
name=f"NWS forecast hourly station {station}",
update_method=nws_data.update_forecast_hourly,
update_interval=DEFAULT_SCAN_INTERVAL,
failed_update_interval=FAILED_SCAN_INTERVAL,
request_refresh_debouncer=debounce.Debouncer(hass,
_LOGGER,
cooldown=DEBOUNCE_TIME,
immediate=True),
)
nws_hass_data = hass.data.setdefault(DOMAIN, {})
nws_hass_data[entry.entry_id] = {
NWS_DATA: nws_data,
COORDINATOR_OBSERVATION: coordinator_observation,
COORDINATOR_FORECAST: coordinator_forecast,
COORDINATOR_FORECAST_HOURLY: coordinator_forecast_hourly,
}
# Fetch initial data so we have data when entities subscribe
await coordinator_observation.async_refresh()
await coordinator_forecast.async_refresh()
await coordinator_forecast_hourly.async_refresh()
hass.config_entries.async_setup_platforms(entry, PLATFORMS)
return True
