async def test_zeroconf_confirm_connection_error(
hass: HomeAssistant, aioclient_mock: AiohttpClientMocker) -> None:
"""Test we abort zeroconf flow on WLED connection error."""
aioclient_mock.get("http://example.com/json/", exc=aiohttp.ClientError)
flow = config_flow.WLEDFlowHandler()
flow.hass = hass
flow.context = {
"source": SOURCE_ZEROCONF,
CONF_HOST: "example.com",
CONF_NAME: "test",
}
result = await flow.async_step_zeroconf_confirm(
user_input={CONF_HOST: "example.com"})
assert result["reason"] == "connection_error"
assert result["type"] == data_entry_flow.RESULT_TYPE_ABORT
async def test_bad_json(
hass: HomeAssistant, aioclient_mock: AiohttpClientMocker, caplog
):
"""Test if it raises an error when there is bad JSON."""
aioclient_mock.get(
"https://kubra.io/stormcenter/api/v1/stormcenters/39e6d9f3-fdea-4539-848f-b8631945da6f/views/74de8a50-3f45-4f6a-9483-fd618bb9165d/currentState?preview=false",
json={"data": {}},
)
config_entry = MockConfigEntry(domain=DOMAIN, data=COUNTY_ENTRY_DATA)
config_entry.add_to_hass(hass)
assert await hass.config_entries.async_setup(config_entry.entry_id)
await hass.async_block_till_done()
assert hass.data[DOMAIN]
assert "ConfigEntryNotReady" in caplog.text
async def test_full_user_flow_implementation(
hass: HomeAssistant, aioclient_mock: AiohttpClientMocker) -> None:
"""Test the full manual user flow from start to finish."""
aioclient_mock.get(
"http://127.0.0.1:9123/elgato/accessory-info",
text=load_fixture("elgato/info.json"),
headers={"Content-Type": CONTENT_TYPE_JSON},
)
# Start a discovered configuration flow, to guarantee a user flow doesn't abort
await hass.config_entries.flow.async_init(
DOMAIN,
context={CONF_SOURCE: SOURCE_ZEROCONF},
data=zeroconf.ZeroconfServiceInfo(
host="127.0.0.1",
hostname="example.local.",
name="mock_name",
port=9123,
properties={},
type="mock_type",
),
)
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={CONF_SOURCE: SOURCE_USER},
)
assert result["step_id"] == "user"
assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
result = await hass.config_entries.flow.async_configure(result["flow_id"],
user_input={
CONF_HOST:
"127.0.0.1",
CONF_PORT: 9123
})
assert result["data"][CONF_HOST] == "127.0.0.1"
assert result["data"][CONF_PORT] == 9123
assert result["data"][CONF_SERIAL_NUMBER] == "CN11A1A00001"
assert result["title"] == "CN11A1A00001"
assert result["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
entries = hass.config_entries.async_entries(DOMAIN)
assert entries[0].unique_id == "CN11A1A00001"
async def test_connection_error(hass: HomeAssistant,
aioclient_mock: AiohttpClientMocker) -> None:
"""Test we show user form on AdGuard Home connection error."""
aioclient_mock.get(
f"{'https' if FIXTURE_USER_INPUT[CONF_SSL] else 'http'}"
f"://{FIXTURE_USER_INPUT[CONF_HOST]}"
f":{FIXTURE_USER_INPUT[CONF_PORT]}/control/status",
exc=aiohttp.ClientError,
)
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": SOURCE_USER}, data=FIXTURE_USER_INPUT)
assert result
assert result.get("type") == data_entry_flow.FlowResultType.FORM
assert result.get("step_id") == "user"
assert result.get("errors") == {"base": "cannot_connect"}
async def test_zeroconf_connection_error(
hass: HomeAssistant, aioclient_mock: AiohttpClientMocker) -> None:
"""Test we abort zeroconf flow on Elgato Key Light connection error."""
aioclient_mock.get("http://1.2.3.4/elgato/accessory-info",
exc=aiohttp.ClientError)
result = await hass.config_entries.flow.async_init(
config_flow.DOMAIN,
context={"source": SOURCE_ZEROCONF},
data={
"host": "1.2.3.4",
"port": 9123
},
)
assert result["reason"] == "cannot_connect"
assert result["type"] == data_entry_flow.RESULT_TYPE_ABORT
async def test_connection_error(hass: HomeAssistant,
aioclient_mock: AiohttpClientMocker) -> None:
"""Test we show user form on AdGuard Home connection error."""
aioclient_mock.get(
f"{'https' if FIXTURE_USER_INPUT[CONF_SSL] else 'http'}"
f"://{FIXTURE_USER_INPUT[CONF_HOST]}"
f":{FIXTURE_USER_INPUT[CONF_PORT]}/control/status",
exc=aiohttp.ClientError,
)
flow = config_flow.AdGuardHomeFlowHandler()
flow.hass = hass
result = await flow.async_step_user(user_input=FIXTURE_USER_INPUT)
assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
assert result["step_id"] == "user"
assert result["errors"] == {"base": "cannot_connect"}
async def test_connection_error(hass: HomeAssistant,
aioclient_mock: AiohttpClientMocker) -> None:
"""Test we show user form on Elgato Key Light connection error."""
aioclient_mock.get("http://example.local/elgato/accessory-info",
exc=aiohttp.ClientError)
flow = config_flow.ElgatoFlowHandler()
flow.hass = hass
flow.context = {"source": SOURCE_USER}
result = await flow.async_step_user(user_input={
CONF_HOST: "example.local",
CONF_PORT: 9123
})
assert result["errors"] == {"base": "connection_error"}
assert result["step_id"] == "user"
assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
async def test_total_update_timeout(
hass: HomeAssistant, aioclient_mock: AiohttpClientMocker, caplog
):
"""Test if it raises an error when there is a timeout."""
aioclient_mock.get(
"https://kubra.io/stormcenter/api/v1/stormcenters/39e6d9f3-fdea-4539-848f-b8631945da6f/views/74de8a50-3f45-4f6a-9483-fd618bb9165d/currentState?preview=false",
exc=asyncio.TimeoutError(),
)
config_entry = MockConfigEntry(domain=DOMAIN, data=MOCK_ENTRY_DATA)
config_entry.add_to_hass(hass)
assert await hass.config_entries.async_setup(config_entry.entry_id)
await hass.async_block_till_done()
assert hass.data[DOMAIN]
assert "Timeout fetching data" in caplog.text
async def test_entry_diagnostics(
hass: HomeAssistant,
hass_client: ClientSession,
mock_config_entry: MockConfigEntry,
aioclient_mock: AiohttpClientMocker,
) -> None:
"""Test config entry diagnostics."""
mock_config_entry.options = {CONF_REPOSITORIES: ["home-assistant/core"]}
response_json = json.loads(load_fixture("graphql.json", DOMAIN))
response_json["data"]["repository"]["full_name"] = "home-assistant/core"
aioclient_mock.post(
"https://api.github.com/graphql",
json=response_json,
headers=json.loads(load_fixture("base_headers.json", DOMAIN)),
)
aioclient_mock.get(
"https://api.github.com/rate_limit",
json={"resources": {
"core": {
"remaining": 100,
"limit": 100
}
}},
headers={"Content-Type": "application/json"},
)
await setup_github_integration(hass, mock_config_entry, aioclient_mock)
result = await get_diagnostics_for_config_entry(
hass,
hass_client,
mock_config_entry,
)
assert result["options"]["repositories"] == ["home-assistant/core"]
assert result["rate_limit"] == {
"resources": {
"core": {
"remaining": 100,
"limit": 100
}
}
}
assert (result["repositories"]["home-assistant/core"]["full_name"] ==
"home-assistant/core")
async def test_connection_error(hass: HomeAssistant,
aioclient_mock: AiohttpClientMocker) -> None:
"""Test we show user form on Elgato Key Light connection error."""
aioclient_mock.get("http://1.2.3.4/elgato/accessory-info",
exc=aiohttp.ClientError)
result = await hass.config_entries.flow.async_init(
config_flow.DOMAIN,
context={"source": SOURCE_USER},
data={
CONF_HOST: "1.2.3.4",
CONF_PORT: 9123
},
)
assert result["errors"] == {"base": "connection_error"}
assert result["step_id"] == "user"
assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
def mock_connection_error(
aioclient_mock: AiohttpClientMocker,
device: str = "roku3",
app: str = "roku",
host: str = HOST,
) -> None:
"""Mock the Roku connection error."""
roku_url = f"http://{host}:8060"
aioclient_mock.get(f"{roku_url}/query/device-info", exc=SocketGIAError)
aioclient_mock.get(f"{roku_url}/query/apps", exc=SocketGIAError)
aioclient_mock.get(f"{roku_url}/query/active-app", exc=SocketGIAError)
aioclient_mock.get(f"{roku_url}/query/tv-active-channel", exc=SocketGIAError)
aioclient_mock.get(f"{roku_url}/query/tv-channels", exc=SocketGIAError)
aioclient_mock.post(re.compile(f"{roku_url}/keypress/.*"), exc=SocketGIAError)
aioclient_mock.post(re.compile(f"{roku_url}/launch/.*"), exc=SocketGIAError)
aioclient_mock.post(f"{roku_url}/search", exc=SocketGIAError)
async def test_zeroconf_confirm_connection_error(
hass: HomeAssistant, aioclient_mock: AiohttpClientMocker
) -> None:
"""Test we abort zeroconf flow on WLED connection error."""
aioclient_mock.get("http://example.com/json/", exc=aiohttp.ClientError)
result = await hass.config_entries.flow.async_init(
config_flow.DOMAIN,
context={
"source": SOURCE_ZEROCONF,
CONF_HOST: "example.com",
CONF_NAME: "test",
},
data={"hostname": "example.com."},
)
assert result["reason"] == "connection_error"
assert result["type"] == data_entry_flow.RESULT_TYPE_ABORT
async def test_zeroconf_connection_error(
update_mock: MagicMock, opp: OpenPeerPower,
aioclient_mock: AiohttpClientMocker) -> None:
"""Test we abort zeroconf flow on WLED connection error."""
aioclient_mock.get("http://192.168.1.123/json/", exc=aiohttp.ClientError)
result = await opp.config_entries.flow.async_init(
DOMAIN,
context={"source": SOURCE_ZEROCONF},
data={
"host": "192.168.1.123",
"hostname": "example.local.",
"properties": {}
},
)
assert result.get("type") == RESULT_TYPE_ABORT
assert result.get("reason") == "cannot_connect"
async def test_zeroconf_connection_error(
update_mock: MagicMock, hass: HomeAssistant,
aioclient_mock: AiohttpClientMocker) -> None:
"""Test we abort zeroconf flow on WLED connection error."""
aioclient_mock.get("http://192.168.1.123/json/", exc=aiohttp.ClientError)
result = await hass.config_entries.flow.async_init(
config_flow.DOMAIN,
context={"source": SOURCE_ZEROCONF},
data={
"host": "192.168.1.123",
"hostname": "example.local.",
"properties": {}
},
)
assert result["reason"] == "connection_error"
assert result["type"] == data_entry_flow.RESULT_TYPE_ABORT
async def test_form_cannot_connect(
hass: HomeAssistant, aioclient_mock: AiohttpClientMocker) -> None:
"""Test we handle cannot connect error."""
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_USER})
aioclient_mock.get(
"http://1.1.1.1:8080/status.json?show_avail=1",
exc=aiohttp.ClientError,
)
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"],
{
"host": "1.1.1.1",
},
)
assert result2["type"] == FlowResultType.FORM
assert result2["errors"] == {"base": "cannot_connect"}
async def test_migrate_entry_failed(hass: HomeAssistant,
aioclient_mock: AiohttpClientMocker,
api_response: str) -> None:
"""Test migrate entry data that fails."""
uri = APIURL_TEMPLATE.format(TEST_CONFIG_MIGRATE["longitude"],
TEST_CONFIG_MIGRATE["latitude"])
aioclient_mock.get(uri, text=api_response)
entry = MockConfigEntry(domain=DOMAIN, data=TEST_CONFIG_MIGRATE)
entry.add_to_hass(hass)
assert entry.version == 1
with patch(
"homeassistant.config_entries.ConfigEntries.async_update_entry",
return_value=False,
):
await hass.config_entries.async_setup(entry.entry_id)
await hass.async_block_till_done()
assert entry.version == 1
async def test_nextdns_system_health_fail(
hass: HomeAssistant, aioclient_mock: AiohttpClientMocker) -> None:
"""Test NextDNS system health."""
aioclient_mock.get(API_ENDPOINT, exc=ClientError)
hass.config.components.add(DOMAIN)
assert await async_setup_component(hass, "system_health", {})
info = await get_system_health_info(hass, DOMAIN)
for key, val in info.items():
if asyncio.iscoroutine(val):
info[key] = await val
assert info == {
"can_reach_server": {
"type": "failed",
"error": "unreachable"
}
}
async def test_full_flow_implementation(
hass: HomeAssistant, aioclient_mock: AiohttpClientMocker) -> None:
"""Test registering an integration and finishing flow works."""
aioclient_mock.get(
"http://127.0.0.1:10000/retrieve",
json=RECEIVE_REPLY,
)
aioclient_mock.post(
"http://127.0.0.1:10000/pair",
json=PAIR_REPLY,
)
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_USER},
data=USER_INPUT,
)
assert result["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
assert result["title"] == UID
assert result["result"].unique_id == UID
async def test_show_zerconf_form(hass: HomeAssistant,
aioclient_mock: AiohttpClientMocker) -> None:
"""Test that the zeroconf confirmation form is served."""
aioclient_mock.get(
"http://example.local:80/json/",
text=load_fixture("wled/rgb.json"),
headers={"Content-Type": "application/json"},
)
flow = config_flow.WLEDFlowHandler()
flow.hass = hass
flow.context = {"source": SOURCE_ZEROCONF}
result = await flow.async_step_zeroconf({"hostname": "example.local."})
assert flow.context[CONF_HOST] == "example.local"
assert flow.context[CONF_NAME] == "example"
assert result["description_placeholders"] == {CONF_NAME: "example"}
assert result["step_id"] == "zeroconf_confirm"
assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
async def test_ssdp_confirm_cannot_connect(
hass: HomeAssistantType, aioclient_mock: AiohttpClientMocker) -> None:
"""Test we abort SSDP flow on connection error."""
aioclient_mock.get("http://127.0.0.1:8080/info/getVersion",
exc=HTTPClientError)
discovery_info = MOCK_SSDP_DISCOVERY_INFO.copy()
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={
CONF_SOURCE: SOURCE_SSDP,
CONF_HOST: HOST,
CONF_NAME: HOST
},
data=discovery_info,
)
assert result["type"] == RESULT_TYPE_ABORT
assert result["reason"] == "cannot_connect"
async def test_connection_error(hass: HomeAssistant,
aioclient_mock: AiohttpClientMocker) -> None:
"""Test we show user form on Agent connection error."""
aioclient_mock.get("http://example.local:8090/command.cgi?cmd=getStatus",
text="")
result = await hass.config_entries.flow.async_init(
config_flow.DOMAIN,
context={"source": SOURCE_USER},
data={
CONF_HOST: "example.local",
CONF_PORT: 8090
},
)
assert result["errors"]["base"] == "cannot_connect"
assert result["step_id"] == "user"
assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
async def test_setup_hass(hass: HomeAssistant,
aioclient_mock: AiohttpClientMocker,
api_response: str) -> None:
"""Test for successfully setting up the smhi integration."""
uri = APIURL_TEMPLATE.format(TEST_CONFIG["location"]["longitude"],
TEST_CONFIG["location"]["latitude"])
aioclient_mock.get(uri, text=api_response)
entry = MockConfigEntry(domain="smhi", data=TEST_CONFIG, version=2)
entry.add_to_hass(hass)
await hass.config_entries.async_setup(entry.entry_id)
await hass.async_block_till_done()
assert aioclient_mock.call_count == 1
# Testing the actual entity state for
# deeper testing than normal unity test
state = hass.states.get(ENTITY_ID)
assert state
assert state.state == "sunny"
assert state.attributes[ATTR_SMHI_CLOUDINESS] == 50
assert state.attributes[ATTR_SMHI_THUNDER_PROBABILITY] == 33
assert state.attributes[ATTR_SMHI_WIND_GUST_SPEED] == 16.92
assert state.attributes[ATTR_ATTRIBUTION].find("SMHI") >= 0
assert state.attributes[ATTR_WEATHER_HUMIDITY] == 55
assert state.attributes[ATTR_WEATHER_PRESSURE] == 1024
assert state.attributes[ATTR_WEATHER_TEMPERATURE] == 17
assert state.attributes[ATTR_WEATHER_VISIBILITY] == 50
assert state.attributes[ATTR_WEATHER_WIND_SPEED] == 6.84
assert state.attributes[ATTR_WEATHER_WIND_BEARING] == 134
assert len(state.attributes["forecast"]) == 4
forecast = state.attributes["forecast"][1]
assert forecast[ATTR_FORECAST_TIME] == "2018-09-02T12:00:00"
assert forecast[ATTR_FORECAST_TEMP] == 21
assert forecast[ATTR_FORECAST_TEMP_LOW] == 6
assert forecast[ATTR_FORECAST_PRECIPITATION] == 0
assert forecast[ATTR_FORECAST_CONDITION] == "partlycloudy"
assert forecast[ATTR_FORECAST_PRESSURE] == 1026
assert forecast[ATTR_FORECAST_WIND_BEARING] == 203
assert forecast[ATTR_FORECAST_WIND_SPEED] == 6.12
async def init_integration(
hass: HomeAssistant,
aioclient_mock: AiohttpClientMocker,
skip_setup: bool = False,
) -> MockConfigEntry:
"""Set up the Elgato Key Light integration in Home Assistant."""
aioclient_mock.get(
"http://example.local:9123/elgato/accessory-info",
text=load_fixture("elgato/info.json"),
headers={"Content-Type": "application/json"},
)
aioclient_mock.put(
"http://example.local:9123/elgato/lights",
text=load_fixture("elgato/state.json"),
headers={"Content-Type": "application/json"},
)
aioclient_mock.get(
"http://example.local:9123/elgato/lights",
text=load_fixture("elgato/state.json"),
headers={"Content-Type": "application/json"},
)
entry = MockConfigEntry(
domain=DOMAIN,
unique_id="CN11A1A00001",
data={
CONF_HOST: "example.local",
CONF_PORT: 9123,
CONF_SERIAL_NUMBER: "CN11A1A00001",
},
)
entry.add_to_hass(hass)
if not skip_setup:
await hass.config_entries.async_setup(entry.entry_id)
await hass.async_block_till_done()
return entry
def pvpc_aioclient_mock(aioclient_mock: AiohttpClientMocker):
"""Create a mock config entry."""
mask_url = "https://apidatos.ree.es/es/datos/mercados/precios-mercados-tiempo-real"
mask_url += "?time_trunc=hour&geo_ids={0}&start_date={1}T00:00&end_date={1}T23:59"
# new format for prices >= 2021-06-01
sample_data = load_fixture(f"{DOMAIN}/{FIXTURE_JSON_DATA_2021_06_01}")
# tariff variant with different geo_ids=8744
aioclient_mock.get(mask_url.format(8741, "2021-06-01"), text=sample_data)
aioclient_mock.get(mask_url.format(8744, "2021-06-01"), text=sample_data)
# simulate missing day
aioclient_mock.get(
mask_url.format(8741, "2021-06-02"),
status=HTTPStatus.BAD_GATEWAY,
text=
('{"errors":[{"code":502,"status":"502","title":"Bad response from ESIOS",'
'"detail":"There are no data for the selected filters."}]}'),
)
return aioclient_mock
async def test_zeroconf_confirm_connection_error(
hass: HomeAssistant, aioclient_mock: AiohttpClientMocker) -> None:
"""Test we abort zeroconf flow on Elgato Key Light connection error."""
aioclient_mock.get("http://1.2.3.4/elgato/accessory-info",
exc=aiohttp.ClientError)
flow = config_flow.ElgatoFlowHandler()
flow.hass = hass
flow.context = {
"source": SOURCE_ZEROCONF,
CONF_HOST: "1.2.3.4",
CONF_PORT: 9123,
}
result = await flow.async_step_zeroconf_confirm(user_input={
CONF_HOST: "1.2.3.4",
CONF_PORT: 9123
})
assert result["reason"] == "connection_error"
assert result["type"] == data_entry_flow.RESULT_TYPE_ABORT
async def test_full_zeroconf_flow_implementation(
opp: OpenPeerPower, aioclient_mock: AiohttpClientMocker) -> None:
"""Test the full manual user flow from start to finish."""
aioclient_mock.get(
"http://192.168.1.123:80/json/",
text=load_fixture("wled/rgb.json"),
headers={"Content-Type": CONTENT_TYPE_JSON},
)
result = await opp.config_entries.flow.async_init(
DOMAIN,
context={"source": SOURCE_ZEROCONF},
data={
"host": "192.168.1.123",
"hostname": "example.local.",
"properties": {}
},
)
flows = opp.config_entries.flow.async_progress()
assert len(flows) == 1
assert result.get("description_placeholders") == {CONF_NAME: "example"}
assert result.get("step_id") == "zeroconf_confirm"
assert result.get("type") == RESULT_TYPE_FORM
assert "flow_id" in result
flow = flows[0]
assert "context" in flow
assert flow["context"][CONF_HOST] == "192.168.1.123"
assert flow["context"][CONF_NAME] == "example"
result2 = await opp.config_entries.flow.async_configure(result["flow_id"],
user_input={})
assert result2.get("title") == "example"
assert result2.get("type") == RESULT_TYPE_CREATE_ENTRY
assert "data" in result2
assert result2["data"][CONF_HOST] == "192.168.1.123"
assert result2["data"][CONF_MAC] == "aabbccddeeff"
async def test_zeroconf_connection_error(
hass: HomeAssistant, aioclient_mock: AiohttpClientMocker) -> None:
"""Test we abort zeroconf flow on Elgato Key Light connection error."""
aioclient_mock.get("http://127.0.0.1/elgato/accessory-info",
exc=aiohttp.ClientError)
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": SOURCE_ZEROCONF},
data=zeroconf.ZeroconfServiceInfo(
host="127.0.0.1",
hostname="mock_hostname",
name="mock_name",
port=9123,
properties={},
type="mock_type",
),
)
assert result["reason"] == "cannot_connect"
assert result["type"] == data_entry_flow.RESULT_TYPE_ABORT
async def test_remove_entry(hass: HomeAssistant,
aioclient_mock: AiohttpClientMocker,
api_response: str) -> None:
"""Test remove entry."""
uri = APIURL_TEMPLATE.format(TEST_CONFIG["location"]["longitude"],
TEST_CONFIG["location"]["latitude"])
aioclient_mock.get(uri, text=api_response)
entry = MockConfigEntry(domain=DOMAIN, data=TEST_CONFIG, version=2)
entry.add_to_hass(hass)
await hass.config_entries.async_setup(entry.entry_id)
await hass.async_block_till_done()
state = hass.states.get(ENTITY_ID)
assert state
await hass.config_entries.async_remove(entry.entry_id)
await hass.async_block_till_done()
state = hass.states.get(ENTITY_ID)
assert not state
async def test_no_alerts(
hass: HomeAssistant,
hass_ws_client,
aioclient_mock: AiohttpClientMocker,
) -> None:
"""Test creating issues based on alerts."""
aioclient_mock.clear_requests()
aioclient_mock.get(
"https://alerts.home-assistant.io/alerts.json",
text="",
)
assert await async_setup_component(hass, DOMAIN, {})
client = await hass_ws_client(hass)
await client.send_json({"id": 1, "type": "repairs/list_issues"})
msg = await client.receive_json()
assert msg["success"]
assert msg["result"] == {"issues": []}
async def test_hassio_confirm(hass: HomeAssistant,
aioclient_mock: AiohttpClientMocker) -> None:
"""Test we can finish a config flow."""
aioclient_mock.get(
"http://mock-adguard:3000/control/status",
json={"version": "v0.99.0"},
headers={"Content-Type": CONTENT_TYPE_JSON},
)
result = await hass.config_entries.flow.async_init(
DOMAIN,
data=HassioServiceInfo(config={
"addon": "AdGuard Home Addon",
"host": "mock-adguard",
"port": 3000
}),
context={"source": config_entries.SOURCE_HASSIO},
)
assert result
assert result.get("type") == data_entry_flow.FlowResultType.FORM
assert result.get("step_id") == "hassio_confirm"
assert result.get("description_placeholders") == {
"addon": "AdGuard Home Addon"
}
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"], {})
assert result2
assert result2.get("type") == data_entry_flow.FlowResultType.CREATE_ENTRY
assert result2.get("title") == "AdGuard Home Addon"
data = result2.get("data")
assert data
assert data[CONF_HOST] == "mock-adguard"
assert data[CONF_PASSWORD] is None
assert data[CONF_PORT] == 3000
assert data[CONF_SSL] is False
assert data[CONF_USERNAME] is None
assert data[CONF_VERIFY_SSL]
