Home-Assistant
/
core
mirror of https://github.com/home-assistant/core.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add Ukraine Alarm integration (#71501) 

Co-authored-by: J. Nick Koston <nick@koston.org>
Co-authored-by: Paulus Schoutsen <paulus@home-assistant.io>
Co-authored-by: Martin Hjelmare <marhje52@gmail.com>
Co-authored-by: Paulus Schoutsen <balloob@gmail.com>
pull/71539/head
Paul Annekov 2022-05-08 18:22:20 +03:00 committed by GitHub
parent d52137cc1a
commit 2eaaa525f4
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
16 changed files with 857 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.coveragerc
View File

@ -1313,6 +1313,9 @@ omit =
homeassistant/components/twitter/notify.py
homeassistant/components/ubus/device_tracker.py
homeassistant/components/ue_smart_radio/media_player.py
homeassistant/components/ukraine_alarm/__init__.py
homeassistant/components/ukraine_alarm/const.py
homeassistant/components/ukraine_alarm/binary_sensor.py
homeassistant/components/unifiled/*
homeassistant/components/upb/__init__.py
homeassistant/components/upb/const.py

2
CODEOWNERS
View File

@ -1071,6 +1071,8 @@ build.json @home-assistant/supervisor
/tests/components/twentemilieu/ @frenck
/homeassistant/components/twinkly/ @dr1rrb @Robbie1221
/tests/components/twinkly/ @dr1rrb @Robbie1221
/homeassistant/components/ukraine_alarm/ @PaulAnnekov
/tests/components/ukraine_alarm/ @PaulAnnekov
/homeassistant/components/unifi/ @Kane610
/tests/components/unifi/ @Kane610
/homeassistant/components/unifiled/ @florisvdk

79
homeassistant/components/ukraine_alarm/__init__.py Normal file
View File

@ -0,0 +1,79 @@
"""The ukraine_alarm component."""
from __future__ import annotations
from datetime import timedelta
import logging
from typing import Any
import aiohttp
from aiohttp import ClientSession
from ukrainealarm.client import Client
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import CONF_API_KEY, CONF_REGION
from homeassistant.core import HomeAssistant
from homeassistant.helpers.aiohttp_client import async_get_clientsession
from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
from .const import ALERT_TYPES, DOMAIN, PLATFORMS
_LOGGER = logging.getLogger(__name__)
UPDATE_INTERVAL = timedelta(seconds=10)
async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
"""Set up Ukraine Alarm as config entry."""
api_key = entry.data[CONF_API_KEY]
region_id = entry.data[CONF_REGION]
websession = async_get_clientsession(hass)
coordinator = UkraineAlarmDataUpdateCoordinator(
hass, websession, api_key, region_id
)
await coordinator.async_config_entry_first_refresh()
hass.data.setdefault(DOMAIN, {})[entry.entry_id] = coordinator
hass.config_entries.async_setup_platforms(entry, PLATFORMS)
return True
async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
"""Unload a config entry."""
if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
hass.data[DOMAIN].pop(entry.entry_id)
return unload_ok
class UkraineAlarmDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
"""Class to manage fetching Ukraine Alarm API."""
def __init__(
self,
hass: HomeAssistant,
session: ClientSession,
api_key: str,
region_id: str,
) -> None:
"""Initialize."""
self.region_id = region_id
self.ukrainealarm = Client(session, api_key)
super().__init__(hass, _LOGGER, name=DOMAIN, update_interval=UPDATE_INTERVAL)
async def _async_update_data(self) -> dict[str, Any]:
"""Update data via library."""
try:
res = await self.ukrainealarm.get_alerts(self.region_id)
except aiohttp.ClientError as error:
raise UpdateFailed(f"Error fetching alerts from API: {error}") from error
current = {alert_type: False for alert_type in ALERT_TYPES}
for alert in res[0]["activeAlerts"]:
current[alert["type"]] = True
return current

106
homeassistant/components/ukraine_alarm/binary_sensor.py Normal file
View File

@ -0,0 +1,106 @@
"""binary sensors for Ukraine Alarm integration."""
from __future__ import annotations
from homeassistant.components.binary_sensor import (
BinarySensorDeviceClass,
BinarySensorEntity,
BinarySensorEntityDescription,
)
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import CONF_NAME
from homeassistant.core import HomeAssistant
from homeassistant.helpers.device_registry import DeviceEntryType
from homeassistant.helpers.entity import DeviceInfo
from homeassistant.helpers.entity_platform import AddEntitiesCallback
from homeassistant.helpers.update_coordinator import CoordinatorEntity
from . import UkraineAlarmDataUpdateCoordinator
from .const import (
ALERT_TYPE_AIR,
ALERT_TYPE_ARTILLERY,
ALERT_TYPE_UNKNOWN,
ALERT_TYPE_URBAN_FIGHTS,
ATTRIBUTION,
DOMAIN,
MANUFACTURER,
)
BINARY_SENSOR_TYPES: tuple[BinarySensorEntityDescription, ...] = (
BinarySensorEntityDescription(
key=ALERT_TYPE_UNKNOWN,
name="Unknown",
device_class=BinarySensorDeviceClass.SAFETY,
),
BinarySensorEntityDescription(
key=ALERT_TYPE_AIR,
name="Air",
device_class=BinarySensorDeviceClass.SAFETY,
icon="mdi:cloud",
),
BinarySensorEntityDescription(
key=ALERT_TYPE_URBAN_FIGHTS,
name="Urban Fights",
device_class=BinarySensorDeviceClass.SAFETY,
icon="mdi:pistol",
),
BinarySensorEntityDescription(
key=ALERT_TYPE_ARTILLERY,
name="Artillery",
device_class=BinarySensorDeviceClass.SAFETY,
icon="mdi:tank",
),
)
async def async_setup_entry(
hass: HomeAssistant,
config_entry: ConfigEntry,
async_add_entities: AddEntitiesCallback,
) -> None:
"""Set up Ukraine Alarm binary sensor entities based on a config entry."""
name = config_entry.data[CONF_NAME]
coordinator = hass.data[DOMAIN][config_entry.entry_id]
async_add_entities(
UkraineAlarmSensor(
name,
config_entry.unique_id,
description,
coordinator,
)
for description in BINARY_SENSOR_TYPES
)
class UkraineAlarmSensor(
CoordinatorEntity[UkraineAlarmDataUpdateCoordinator], BinarySensorEntity
):
"""Class for a Ukraine Alarm binary sensor."""
_attr_attribution = ATTRIBUTION
def __init__(
self,
name,
unique_id,
description: BinarySensorEntityDescription,
coordinator: UkraineAlarmDataUpdateCoordinator,
) -> None:
"""Initialize the sensor."""
super().__init__(coordinator)
self.entity_description = description
self._attr_name = f"{name} {description.name}"
self._attr_unique_id = f"{unique_id}-{description.key}".lower()
self._attr_device_info = DeviceInfo(
entry_type=DeviceEntryType.SERVICE,
identifiers={(DOMAIN, unique_id)},
manufacturer=MANUFACTURER,
name=name,
)
@property
def is_on(self) -> bool | None:
"""Return true if the binary sensor is on."""
return self.coordinator.data.get(self.entity_description.key, None)

154
homeassistant/components/ukraine_alarm/config_flow.py Normal file
View File

@ -0,0 +1,154 @@
"""Config flow for Ukraine Alarm."""
from __future__ import annotations
import asyncio
import aiohttp
from ukrainealarm.client import Client
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.const import CONF_API_KEY, CONF_NAME, CONF_REGION
from homeassistant.helpers.aiohttp_client import async_get_clientsession
from .const import DOMAIN
class UkraineAlarmConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
"""Config flow for Ukraine Alarm."""
VERSION = 1
def __init__(self):
"""Initialize a new UkraineAlarmConfigFlow."""
self.api_key = None
self.states = None
self.selected_region = None
async def async_step_user(self, user_input=None):
"""Handle a flow initialized by the user."""
errors = {}
if user_input is not None:
websession = async_get_clientsession(self.hass)
try:
regions = await Client(
websession, user_input[CONF_API_KEY]
).get_regions()
except aiohttp.ClientResponseError as ex:
errors["base"] = "invalid_api_key" if ex.status == 401 else "unknown"
except aiohttp.ClientConnectionError:
errors["base"] = "cannot_connect"
except aiohttp.ClientError:
errors["base"] = "unknown"
except asyncio.TimeoutError:
errors["base"] = "timeout"
if not errors and not regions:
errors["base"] = "unknown"
if not errors:
self.api_key = user_input[CONF_API_KEY]
self.states = regions["states"]
return await self.async_step_state()
schema = vol.Schema(
{
vol.Required(CONF_API_KEY): str,
}
)
return self.async_show_form(
step_id="user",
data_schema=schema,
description_placeholders={"api_url": "https://api.ukrainealarm.com/"},
errors=errors,
last_step=False,
)
async def async_step_state(self, user_input=None):
"""Handle user-chosen state."""
return await self._handle_pick_region("state", "district", user_input)
async def async_step_district(self, user_input=None):
"""Handle user-chosen district."""
return await self._handle_pick_region("district", "community", user_input)
async def async_step_community(self, user_input=None):
"""Handle user-chosen community."""
return await self._handle_pick_region("community", None, user_input, True)
async def _handle_pick_region(
self, step_id: str, next_step: str | None, user_input, last_step=False
):
"""Handle picking a (sub)region."""
if self.selected_region:
source = self.selected_region["regionChildIds"]
else:
source = self.states
if user_input is not None:
# Only offer to browse subchildren if picked region wasn't the previously picked one
if (
not self.selected_region
or user_input[CONF_REGION] != self.selected_region["regionId"]
):
self.selected_region = _find(source, user_input[CONF_REGION])
if next_step and self.selected_region["regionChildIds"]:
return await getattr(self, f"async_step_{next_step}")()
return await self._async_finish_flow()
regions = {}
if self.selected_region:
regions[self.selected_region["regionId"]] = self.selected_region[
"regionName"
]
regions.update(_make_regions_object(source))
schema = vol.Schema(
{
vol.Required(CONF_REGION): vol.In(regions),
}
)
return self.async_show_form(
step_id=step_id, data_schema=schema, last_step=last_step
)
async def _async_finish_flow(self):
"""Finish the setup."""
await self.async_set_unique_id(self.selected_region["regionId"])
self._abort_if_unique_id_configured()
return self.async_create_entry(
title=self.selected_region["regionName"],
data={
CONF_API_KEY: self.api_key,
CONF_REGION: self.selected_region["regionId"],
CONF_NAME: self.selected_region["regionName"],
},
)
def _find(regions, region_id):
return next((region for region in regions if region["regionId"] == region_id), None)
def _make_regions_object(regions):
regions_list = []
for region in regions:
regions_list.append(
{
"id": region["regionId"],
"name": region["regionName"],
}
)
regions_list = sorted(regions_list, key=lambda region: region["name"].lower())
regions_object = {}
for region in regions_list:
regions_object[region["id"]] = region["name"]
return regions_object

19
homeassistant/components/ukraine_alarm/const.py Normal file
View File

@ -0,0 +1,19 @@
"""Consts for the Ukraine Alarm."""
from __future__ import annotations
from homeassistant.const import Platform
DOMAIN = "ukraine_alarm"
ATTRIBUTION = "Data provided by Ukraine Alarm"
MANUFACTURER = "Ukraine Alarm"
ALERT_TYPE_UNKNOWN = "UNKNOWN"
ALERT_TYPE_AIR = "AIR"
ALERT_TYPE_ARTILLERY = "ARTILLERY"
ALERT_TYPE_URBAN_FIGHTS = "URBAN_FIGHTS"
ALERT_TYPES = {
ALERT_TYPE_UNKNOWN,
ALERT_TYPE_AIR,
ALERT_TYPE_ARTILLERY,
ALERT_TYPE_URBAN_FIGHTS,
}
PLATFORMS = [Platform.BINARY_SENSOR]

9
homeassistant/components/ukraine_alarm/manifest.json Normal file
View File

@ -0,0 +1,9 @@
{
"domain": "ukraine_alarm",
"name": "Ukraine Alarm",
"config_flow": true,
"documentation": "https://www.home-assistant.io/integrations/ukraine_alarm",
"requirements": ["ukrainealarm==0.0.1"],
"codeowners": ["@PaulAnnekov"],
"iot_class": "cloud_polling"
}

39
homeassistant/components/ukraine_alarm/strings.json Normal file
View File

@ -0,0 +1,39 @@
{
"config": {
"abort": {
"already_configured": "[%key:common::config_flow::abort::already_configured_location%]"
},
"error": {
"invalid_api_key": "[%key:common::config_flow::error::invalid_api_key%]",
"cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
"unknown": "[%key:common::config_flow::error::unknown%]",
"timeout": "[%key:common::config_flow::error::timeout_connect%]"
},
"step": {
"user": {
"data": {
"api_key": "[%key:common::config_flow::data::api_key%]"
},
"description": "Set up the Ukraine Alarm integration. To generate an API key go to {api_url}"
},
"state": {
"data": {
"region": "Region"
},
"description": "Choose state to monitor"
},
"district": {
"data": {
"region": "[%key:component::ukraine_alarm::config::step::state::data::region%]"
},
"description": "If you want to monitor not only state, choose its specific district"
},
"community": {
"data": {
"region": "[%key:component::ukraine_alarm::config::step::state::data::region%]"
},
"description": "If you want to monitor not only state and district, choose its specific community"
}
}
}
}

28
homeassistant/components/ukraine_alarm/translations/en.json Normal file
View File

@ -0,0 +1,28 @@
{
"config": {
"step": {
"user": {
"description": "Set up the Ukraine Alarm integration. To generate an API key go to {api_url}",
"title": "Ukraine Alarm"
},
"state": {
"data": {
"region": "Region"
},
"description": "Choose state to monitor"
},
"district": {
"data": {
"region": "Region"
},
"description": "If you want to monitor not only state, choose its specific district"
},
"community": {
"data": {
"region": "Region"
},
"description": "If you want to monitor not only state and district, choose its specific community"
}
}
}
}

28
homeassistant/components/ukraine_alarm/translations/ru.json Normal file
View File

@ -0,0 +1,28 @@
{
"config": {
"step": {
"user": {
"description": "\u041d\u0430\u0441\u0442\u0440\u043e\u0439\u043a\u0430 Home Assistant \u0434\u043b\u044f\u0020\u0438\u043d\u0442\u0435\u0433\u0440\u0430\u0446\u0438\u0438\u0020\u0441 Ukraine Alarm. \u0414\u043b\u044f\u0020\u043f\u043e\u043b\u0443\u0447\u0435\u043d\u0438\u044f\u0020\u043a\u043b\u044e\u0447\u0430 API, \u043f\u0435\u0440\u0435\u0439\u0434\u0438\u0442\u0435\u0020\u043d\u0430 {api_url}.",
"title": "Ukraine Alarm"
},
"state": {
"data": {
"region": "\u0420\u0435\u0433\u0438\u043e\u043d"
},
"description": "\u0412\u044b\u0431\u0435\u0440\u0438\u0442\u0435\u0020\u043e\u0431\u043b\u0430\u0441\u0442\u044c\u0020\u0434\u043b\u044f\u0020\u043c\u043e\u043d\u0438\u0442\u043e\u0440\u0438\u043d\u0433\u0430"
},
"district": {
"data": {
"region": "\u0420\u0435\u0433\u0438\u043e\u043d"
},
"description": "\u0415\u0441\u043b\u0438\u0020\u0432\u044b\u0020\u0436\u0435\u043b\u0430\u0435\u0442\u0435\u0020\u043c\u043e\u043d\u0438\u0442\u043e\u0440\u0438\u0442\u044c\u0020\u043d\u0435\u0020\u0442\u043e\u043b\u044c\u043a\u043e\u0020\u043e\u0431\u043b\u0430\u0441\u0442\u044c\u002c\u0020\u0432\u044b\u0431\u0435\u0440\u0438\u0442\u0435\u0020\u0435\u0451\u0020\u0440\u0430\u0439\u043e\u043d"
},
"community": {
"data": {
"region": "\u0420\u0435\u0433\u0438\u043e\u043d"
},
"description": "\u0415\u0441\u043b\u0438\u0020\u0432\u044b\u0020\u0436\u0435\u043b\u0430\u0435\u0442\u0435\u0020\u043c\u043e\u043d\u0438\u0442\u043e\u0440\u0438\u0442\u044c\u0020\u043d\u0435\u0020\u0442\u043e\u043b\u044c\u043a\u043e\u0020\u043e\u0431\u043b\u0430\u0441\u0442\u044c\u0020\u0438\u0020\u0440\u0430\u0439\u043e\u043d\u002c\u0020\u0432\u044b\u0431\u0435\u0440\u0438\u0442\u0435\u0020\u0435\u0451\u0020\u0433\u0440\u043e\u043c\u0430\u0434\u0443"
}
}
}
}

28
homeassistant/components/ukraine_alarm/translations/uk.json Normal file
View File

@ -0,0 +1,28 @@
{
"config": {
"step": {
"user": {
"description": "\u041d\u0430\u043b\u0430\u0448\u0442\u0443\u0439\u0442\u0435 Home Assistant \u0434\u043b\u044f\u0020\u0456\u043d\u0442\u0435\u0433\u0440\u0430\u0446\u0456\u0457\u0020\u0437 Ukraine Alarm. \u0414\u043b\u044f\u0020\u043e\u0442\u0440\u0438\u043c\u0430\u043d\u043d\u044f\u0020\u043a\u043b\u044e\u0447\u0430 API, \u043f\u0435\u0440\u0435\u0439\u0434\u0456\u0442\u044c\u0020\u043d\u0430 {api_url}.",
"title": "Ukraine Alarm"
},
"state": {
"data": {
"region": "\u0420\u0435\u0433\u0456\u043e\u043d"
},
"description": "\u041e\u0431\u0435\u0440\u0456\u0442\u044c\u0020\u043e\u0431\u043b\u0430\u0441\u0442\u044c\u0020\u0434\u043b\u044f\u0020\u043c\u043e\u043d\u0456\u0442\u043e\u0440\u0438\u043d\u0433\u0443"
},
"district": {
"data": {
"region": "\u0420\u0435\u0433\u0456\u043e\u043d"
},
"description": "\u042f\u043a\u0449\u043e\u0020\u0432\u0438\u0020\u0431\u0430\u0436\u0430\u0454\u0442\u0435\u0020\u043c\u043e\u043d\u0456\u0442\u043e\u0440\u0438\u0442\u0438\u0020\u043d\u0435\u0020\u043b\u0438\u0448\u0435\u0020\u043e\u0431\u043b\u0430\u0441\u0442\u044c\u002c\u0020\u043e\u0431\u0435\u0440\u0456\u0442\u044c\u0020\u0457\u0457\u0020\u0440\u0430\u0439\u043e\u043d"
},
"community": {
"data": {
"region": "\u0420\u0435\u0433\u0456\u043e\u043d"
},
"description": "\u042f\u043a\u0449\u043e\u0020\u0432\u0438\u0020\u0431\u0430\u0436\u0430\u0454\u0442\u0435\u0020\u043c\u043e\u043d\u0456\u0442\u043e\u0440\u0438\u0442\u0438\u0020\u043d\u0435\u0020\u0442\u0456\u043b\u044c\u043a\u0438\u0020\u043e\u0431\u043b\u0430\u0441\u0442\u044c\u0020\u0442\u0430\u0020\u0440\u0430\u0439\u043e\u043d\u002c\u0020\u043e\u0431\u0435\u0440\u0456\u0442\u044c\u0020\u0457\u0457\u0020\u0433\u0440\u043e\u043c\u0430\u0434\u0443"
}
}
}
}

1
homeassistant/generated/config_flows.py
View File

@ -366,6 +366,7 @@ FLOWS = {
"twentemilieu",
"twilio",
"twinkly",
"ukraine_alarm",
"unifi",
"unifiprotect",
"upb",

3
requirements_all.txt
View File

@ -2345,6 +2345,9 @@ twitchAPI==2.5.2
# homeassistant.components.rainforest_eagle
uEagle==0.0.2
# homeassistant.components.ukraine_alarm
ukrainealarm==0.0.1
# homeassistant.components.unifiprotect
unifi-discovery==1.1.2

3
requirements_test_all.txt
View File

@ -1527,6 +1527,9 @@ twitchAPI==2.5.2
# homeassistant.components.rainforest_eagle
uEagle==0.0.2
# homeassistant.components.ukraine_alarm
ukrainealarm==0.0.1
# homeassistant.components.unifiprotect
unifi-discovery==1.1.2

1
tests/components/ukraine_alarm/__init__.py Normal file
View File

@ -0,0 +1 @@
"""Tests for the Ukraine Alarm integration."""

354
tests/components/ukraine_alarm/test_config_flow.py Normal file
View File

@ -0,0 +1,354 @@
"""Test the Ukraine Alarm config flow."""
import asyncio
from collections.abc import Generator
from unittest.mock import AsyncMock, patch
from aiohttp import ClientConnectionError, ClientError, ClientResponseError
import pytest
from homeassistant import config_entries
from homeassistant.components.ukraine_alarm.const import DOMAIN
from homeassistant.core import HomeAssistant
from homeassistant.data_entry_flow import RESULT_TYPE_CREATE_ENTRY, RESULT_TYPE_FORM
MOCK_API_KEY = "mock-api-key"
def _region(rid, recurse=0, depth=0):
if depth == 0:
name_prefix = "State"
elif depth == 1:
name_prefix = "District"
else:
name_prefix = "Community"
name = f"{name_prefix} {rid}"
region = {"regionId": rid, "regionName": name, "regionChildIds": []}
if not recurse:
return region
for i in range(1, 4):
region["regionChildIds"].append(_region(f"{rid}.{i}", recurse - 1, depth + 1))
return region
REGIONS = {
"states": [_region(f"{i}", i - 1) for i in range(1, 4)],
}
@pytest.fixture(autouse=True)
def mock_get_regions() -> Generator[None, AsyncMock, None]:
"""Mock the get_regions method."""
with patch(
"homeassistant.components.ukraine_alarm.config_flow.Client.get_regions",
return_value=REGIONS,
) as mock_get:
yield mock_get
async def test_state(hass: HomeAssistant) -> None:
"""Test we can create entry for state."""
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_USER}
)
assert result["type"] == RESULT_TYPE_FORM
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"],
{
"api_key": MOCK_API_KEY,
},
)
assert result2["type"] == RESULT_TYPE_FORM
with patch(
"homeassistant.components.ukraine_alarm.async_setup_entry",
return_value=True,
) as mock_setup_entry:
result3 = await hass.config_entries.flow.async_configure(
result["flow_id"],
{
"region": "1",
},
)
await hass.async_block_till_done()
assert result3["type"] == RESULT_TYPE_CREATE_ENTRY
assert result3["title"] == "State 1"
assert result3["data"] == {
"api_key": MOCK_API_KEY,
"region": "1",
"name": result3["title"],
}
assert len(mock_setup_entry.mock_calls) == 1
async def test_state_district(hass: HomeAssistant) -> None:
"""Test we can create entry for state + district."""
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_USER}
)
assert result["type"] == RESULT_TYPE_FORM
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"],
{
"api_key": MOCK_API_KEY,
},
)
assert result2["type"] == RESULT_TYPE_FORM
result3 = await hass.config_entries.flow.async_configure(
result["flow_id"],
{
"region": "2",
},
)
assert result3["type"] == RESULT_TYPE_FORM
with patch(
"homeassistant.components.ukraine_alarm.async_setup_entry",
return_value=True,
) as mock_setup_entry:
result4 = await hass.config_entries.flow.async_configure(
result["flow_id"],
{
"region": "2.2",
},
)
await hass.async_block_till_done()
assert result4["type"] == RESULT_TYPE_CREATE_ENTRY
assert result4["title"] == "District 2.2"
assert result4["data"] == {
"api_key": MOCK_API_KEY,
"region": "2.2",
"name": result4["title"],
}
assert len(mock_setup_entry.mock_calls) == 1
async def test_state_district_pick_region(hass: HomeAssistant) -> None:
"""Test we can create entry for region which has districts."""
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_USER}
)
assert result["type"] == RESULT_TYPE_FORM
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"],
{
"api_key": MOCK_API_KEY,
},
)
assert result2["type"] == RESULT_TYPE_FORM
result3 = await hass.config_entries.flow.async_configure(
result["flow_id"],
{
"region": "2",
},
)
assert result3["type"] == RESULT_TYPE_FORM
with patch(
"homeassistant.components.ukraine_alarm.async_setup_entry",
return_value=True,
) as mock_setup_entry:
result4 = await hass.config_entries.flow.async_configure(
result["flow_id"],
{
"region": "2",
},
)
await hass.async_block_till_done()
assert result4["type"] == RESULT_TYPE_CREATE_ENTRY
assert result4["title"] == "State 2"
assert result4["data"] == {
"api_key": MOCK_API_KEY,
"region": "2",
"name": result4["title"],
}
assert len(mock_setup_entry.mock_calls) == 1
async def test_state_district_community(hass: HomeAssistant) -> None:
"""Test we can create entry for state + district + community."""
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_USER}
)
assert result["type"] == RESULT_TYPE_FORM
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"],
{
"api_key": MOCK_API_KEY,
},
)
assert result2["type"] == RESULT_TYPE_FORM
result3 = await hass.config_entries.flow.async_configure(
result["flow_id"],
{
"region": "3",
},
)
assert result3["type"] == RESULT_TYPE_FORM
result4 = await hass.config_entries.flow.async_configure(
result["flow_id"],
{
"region": "3.2",
},
)
assert result4["type"] == RESULT_TYPE_FORM
with patch(
"homeassistant.components.ukraine_alarm.async_setup_entry",
return_value=True,
) as mock_setup_entry:
result5 = await hass.config_entries.flow.async_configure(
result["flow_id"],
{
"region": "3.2.1",
},
)
await hass.async_block_till_done()
assert result5["type"] == RESULT_TYPE_CREATE_ENTRY
assert result5["title"] == "Community 3.2.1"
assert result5["data"] == {
"api_key": MOCK_API_KEY,
"region": "3.2.1",
"name": result5["title"],
}
assert len(mock_setup_entry.mock_calls) == 1
async def test_invalid_api(hass: HomeAssistant, mock_get_regions: AsyncMock) -> None:
"""Test we can create entry for just region."""
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_USER}
)
assert result["type"] == RESULT_TYPE_FORM
mock_get_regions.side_effect = ClientResponseError(None, None, status=401)
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"],
{
"api_key": MOCK_API_KEY,
},
)
assert result2["type"] == RESULT_TYPE_FORM
assert result2["step_id"] == "user"
assert result2["errors"] == {"base": "invalid_api_key"}
async def test_server_error(hass: HomeAssistant, mock_get_regions) -> None:
"""Test we can create entry for just region."""
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_USER}
)
assert result["type"] == RESULT_TYPE_FORM
mock_get_regions.side_effect = ClientResponseError(None, None, status=500)
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"],
{
"api_key": MOCK_API_KEY,
},
)
assert result2["type"] == RESULT_TYPE_FORM
assert result2["step_id"] == "user"
assert result2["errors"] == {"base": "unknown"}
async def test_cannot_connect(hass: HomeAssistant, mock_get_regions: AsyncMock) -> None:
"""Test we can create entry for just region."""
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_USER}
)
assert result["type"] == RESULT_TYPE_FORM
mock_get_regions.side_effect = ClientConnectionError
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"],
{
"api_key": MOCK_API_KEY,
},
)
assert result2["type"] == RESULT_TYPE_FORM
assert result2["step_id"] == "user"
assert result2["errors"] == {"base": "cannot_connect"}
async def test_unknown_client_error(
hass: HomeAssistant, mock_get_regions: AsyncMock
) -> None:
"""Test we can create entry for just region."""
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_USER}
)
assert result["type"] == RESULT_TYPE_FORM
mock_get_regions.side_effect = ClientError
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"],
{
"api_key": MOCK_API_KEY,
},
)
assert result2["type"] == RESULT_TYPE_FORM
assert result2["step_id"] == "user"
assert result2["errors"] == {"base": "unknown"}
async def test_timeout_error(hass: HomeAssistant, mock_get_regions: AsyncMock) -> None:
"""Test we can create entry for just region."""
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_USER}
)
assert result["type"] == RESULT_TYPE_FORM
mock_get_regions.side_effect = asyncio.TimeoutError
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"],
{
"api_key": MOCK_API_KEY,
},
)
assert result2["type"] == RESULT_TYPE_FORM
assert result2["step_id"] == "user"
assert result2["errors"] == {"base": "timeout"}
async def test_no_regions_returned(
hass: HomeAssistant, mock_get_regions: AsyncMock
) -> None:
"""Test we can create entry for just region."""
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_USER}
)
assert result["type"] == RESULT_TYPE_FORM
mock_get_regions.return_value = {}
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"],
{
"api_key": MOCK_API_KEY,
},
)
assert result2["type"] == RESULT_TYPE_FORM
assert result2["step_id"] == "user"
assert result2["errors"] == {"base": "unknown"}