163 lines
5.3 KiB
Python
163 lines
5.3 KiB
Python
"""Common test code."""
|
|
from typing import List, NamedTuple, Optional
|
|
from unittest.mock import MagicMock, Mock
|
|
|
|
from gogogate2_api import GogoGate2Api, InfoResponse
|
|
from gogogate2_api.common import Door, DoorMode, DoorStatus, Network, Outputs, Wifi
|
|
|
|
from homeassistant.components import persistent_notification
|
|
from homeassistant.components.cover import DOMAIN as COVER_DOMAIN
|
|
from homeassistant.components.gogogate2 import async_unload_entry
|
|
from homeassistant.components.gogogate2.common import (
|
|
GogoGateDataUpdateCoordinator,
|
|
get_data_update_coordinator,
|
|
)
|
|
import homeassistant.components.gogogate2.const as const
|
|
from homeassistant.components.homeassistant import DOMAIN as HA_DOMAIN
|
|
from homeassistant.config import async_process_ha_core_config
|
|
from homeassistant.config_entries import SOURCE_USER
|
|
from homeassistant.const import CONF_UNIT_SYSTEM, CONF_UNIT_SYSTEM_METRIC
|
|
from homeassistant.core import HomeAssistant
|
|
from homeassistant.data_entry_flow import RESULT_TYPE_CREATE_ENTRY, RESULT_TYPE_FORM
|
|
from homeassistant.setup import async_setup_component
|
|
|
|
INFO_RESPONSE = InfoResponse(
|
|
user="user1",
|
|
gogogatename="gogogatename1",
|
|
model="",
|
|
apiversion="",
|
|
remoteaccessenabled=False,
|
|
remoteaccess="abcdefg.my-gogogate.com",
|
|
firmwareversion="",
|
|
apicode="API_CODE",
|
|
door1=Door(
|
|
door_id=1,
|
|
permission=True,
|
|
name="Door1",
|
|
mode=DoorMode.GARAGE,
|
|
status=DoorStatus.OPENED,
|
|
sensor=True,
|
|
sensorid=None,
|
|
camera=False,
|
|
events=2,
|
|
temperature=None,
|
|
),
|
|
door2=Door(
|
|
door_id=2,
|
|
permission=True,
|
|
name=None,
|
|
mode=DoorMode.GARAGE,
|
|
status=DoorStatus.OPENED,
|
|
sensor=True,
|
|
sensorid=None,
|
|
camera=False,
|
|
events=2,
|
|
temperature=None,
|
|
),
|
|
door3=Door(
|
|
door_id=3,
|
|
permission=True,
|
|
name="Door3",
|
|
mode=DoorMode.GARAGE,
|
|
status=DoorStatus.OPENED,
|
|
sensor=True,
|
|
sensorid=None,
|
|
camera=False,
|
|
events=2,
|
|
temperature=None,
|
|
),
|
|
outputs=Outputs(output1=True, output2=False, output3=True),
|
|
network=Network(ip=""),
|
|
wifi=Wifi(SSID="", linkquality="", signal=""),
|
|
)
|
|
|
|
|
|
class ComponentData(NamedTuple):
|
|
"""Test data for a mocked component."""
|
|
|
|
api: GogoGate2Api
|
|
data_update_coordinator: GogoGateDataUpdateCoordinator
|
|
|
|
|
|
class ComponentFactory:
|
|
"""Manages the setup and unloading of the withing component and profiles."""
|
|
|
|
def __init__(self, hass: HomeAssistant, gogogate_api_mock: Mock) -> None:
|
|
"""Initialize the object."""
|
|
self._hass = hass
|
|
self._gogogate_api_mock = gogogate_api_mock
|
|
|
|
@property
|
|
def api_class_mock(self):
|
|
"""Get the api class mock."""
|
|
return self._gogogate_api_mock
|
|
|
|
async def configure_component(
|
|
self, cover_config: Optional[List[dict]] = None
|
|
) -> None:
|
|
"""Configure the component."""
|
|
hass_config = {
|
|
"homeassistant": {CONF_UNIT_SYSTEM: CONF_UNIT_SYSTEM_METRIC},
|
|
"cover": cover_config or [],
|
|
}
|
|
|
|
await async_process_ha_core_config(self._hass, hass_config.get("homeassistant"))
|
|
assert await async_setup_component(self._hass, HA_DOMAIN, {})
|
|
assert await async_setup_component(
|
|
self._hass, persistent_notification.DOMAIN, {}
|
|
)
|
|
assert await async_setup_component(self._hass, COVER_DOMAIN, hass_config)
|
|
assert await async_setup_component(self._hass, const.DOMAIN, hass_config)
|
|
await self._hass.async_block_till_done()
|
|
|
|
async def run_config_flow(
|
|
self, config_data: dict, api_mock: Optional[GogoGate2Api] = None
|
|
) -> ComponentData:
|
|
"""Run a config flow."""
|
|
if api_mock is None:
|
|
api_mock: GogoGate2Api = MagicMock(spec=GogoGate2Api)
|
|
api_mock.info.return_value = INFO_RESPONSE
|
|
|
|
self._gogogate_api_mock.reset_mocks()
|
|
self._gogogate_api_mock.return_value = api_mock
|
|
|
|
result = await self._hass.config_entries.flow.async_init(
|
|
const.DOMAIN, context={"source": SOURCE_USER}
|
|
)
|
|
assert result
|
|
assert result["type"] == RESULT_TYPE_FORM
|
|
assert result["step_id"] == "user"
|
|
|
|
result = await self._hass.config_entries.flow.async_configure(
|
|
result["flow_id"], user_input=config_data,
|
|
)
|
|
assert result
|
|
assert result["type"] == RESULT_TYPE_CREATE_ENTRY
|
|
assert result["data"] == config_data
|
|
|
|
await self._hass.async_block_till_done()
|
|
|
|
config_entry = next(
|
|
iter(
|
|
entry
|
|
for entry in self._hass.config_entries.async_entries(const.DOMAIN)
|
|
if entry.unique_id == "abcdefg"
|
|
)
|
|
)
|
|
|
|
return ComponentData(
|
|
api=api_mock,
|
|
data_update_coordinator=get_data_update_coordinator(
|
|
self._hass, config_entry
|
|
),
|
|
)
|
|
|
|
async def unload(self) -> None:
|
|
"""Unload all config entries."""
|
|
config_entries = self._hass.config_entries.async_entries(const.DOMAIN)
|
|
for config_entry in config_entries:
|
|
await async_unload_entry(self._hass, config_entry)
|
|
|
|
await self._hass.async_block_till_done()
|
|
assert not self._hass.states.async_entity_ids("gogogate")
|