starred/core
1
0
Fork 0
mirror of https://github.com/home-assistant/core.git synced 2026-09-28 02:18:10 -04:00
Code Issues Packages Projects Releases Wiki Activity

Add Huisbaasje integration (#42716)

Browse Source 
Co-authored-by: Paulus Schoutsen <paulus@home-assistant.io>
Co-authored-by: Franck Nijhof <frenck@frenck.nl>
This commit is contained in:
Dennis Schroer
2021-01-27 15:53:25 +01:00
committed by GitHub
co-authored by Paulus Schoutsen Franck Nijhof
parent b4af17e02d
commit 8d572af77a
15 changed files with 1038 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/components/huisbaasje/__init__.py
+1
View File
@@ -0,0 +1 @@
"""Tests for the Huisbaasje integration."""
tests/components/huisbaasje/test_config_flow.py
+157
View File
@@ -0,0 +1,157 @@
"""Test the Huisbaasje config flow."""
from unittest.mock import patch
from homeassistant import config_entries, data_entry_flow, setup
from homeassistant.components.huisbaasje.config_flow import (
HuisbaasjeConnectionException,
HuisbaasjeException,
)
from homeassistant.components.huisbaasje.const import DOMAIN
from tests.common import MockConfigEntry
async def test_form(hass):
"""Test we get the form."""
await setup.async_setup_component(hass, "persistent_notification", {})
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_USER}
)
assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
assert result["errors"] == {}
with patch(
"huisbaasje.Huisbaasje.authenticate", return_value=None
) as mock_authenticate, patch(
"huisbaasje.Huisbaasje.get_user_id",
return_value="test-id",
) as mock_get_user_id, patch(
"homeassistant.components.huisbaasje.async_setup", return_value=True
) as mock_setup, patch(
"homeassistant.components.huisbaasje.async_setup_entry",
return_value=True,
) as mock_setup_entry:
form_result = await hass.config_entries.flow.async_configure(
result["flow_id"],
{
"username": "test-username",
"password": "test-password",
},
)
await hass.async_block_till_done()
assert form_result["type"] == "create_entry"
assert form_result["title"] == "test-username"
assert form_result["data"] == {
"id": "test-id",
"username": "test-username",
"password": "test-password",
}
assert len(mock_authenticate.mock_calls) == 1
assert len(mock_get_user_id.mock_calls) == 1
assert len(mock_setup.mock_calls) == 1
assert len(mock_setup_entry.mock_calls) == 1
async def test_form_invalid_auth(hass):
"""Test we handle invalid auth."""
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_USER}
)
with patch(
"huisbaasje.Huisbaasje.authenticate",
side_effect=HuisbaasjeException,
):
form_result = await hass.config_entries.flow.async_configure(
result["flow_id"],
{
"username": "test-username",
"password": "test-password",
},
)
assert form_result["type"] == data_entry_flow.RESULT_TYPE_FORM
assert form_result["errors"] == {"base": "invalid_auth"}
async def test_form_cannot_connect(hass):
"""Test we handle cannot connect error."""
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_USER}
)
with patch(
"huisbaasje.Huisbaasje.authenticate",
side_effect=HuisbaasjeConnectionException,
):
form_result = await hass.config_entries.flow.async_configure(
result["flow_id"],
{
"username": "test-username",
"password": "test-password",
},
)
assert form_result["type"] == data_entry_flow.RESULT_TYPE_FORM
assert form_result["errors"] == {"base": "connection_exception"}
async def test_form_unknown_error(hass):
"""Test we handle an unknown error."""
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_USER}
)
with patch(
"huisbaasje.Huisbaasje.authenticate",
side_effect=Exception,
):
form_result = await hass.config_entries.flow.async_configure(
result["flow_id"],
{
"username": "test-username",
"password": "test-password",
},
)
assert form_result["type"] == data_entry_flow.RESULT_TYPE_FORM
assert form_result["errors"] == {"base": "unknown"}
async def test_form_entry_exists(hass):
"""Test we handle an already existing entry."""
MockConfigEntry(
unique_id="test-id",
domain=DOMAIN,
data={
"id": "test-id",
"username": "test-username",
"password": "test-password",
},
title="test-username",
).add_to_hass(hass)
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_USER}
)
with patch("huisbaasje.Huisbaasje.authenticate", return_value=None), patch(
"huisbaasje.Huisbaasje.get_user_id",
return_value="test-id",
), patch(
"homeassistant.components.huisbaasje.async_setup", return_value=True
), patch(
"homeassistant.components.huisbaasje.async_setup_entry",
return_value=True,
):
form_result = await hass.config_entries.flow.async_configure(
result["flow_id"],
{
"username": "test-username",
"password": "test-password",
},
)
assert form_result["type"] == data_entry_flow.RESULT_TYPE_ABORT
assert form_result["reason"] == "already_configured"
tests/components/huisbaasje/test_data.py
+79
View File
@@ -0,0 +1,79 @@
"""Test data for the tests of the Huisbaasje integration."""
MOCK_CURRENT_MEASUREMENTS = {
"electricity": {
"measurement": {
"time": "2020-11-18T15:17:24.000Z",
"rate": 1011.6666666666667,
"value": 0.0033333333333333335,
"costPerHour": 0.20233333333333337,
"counterValue": 409.17166666631937,
},
"thisDay": {"value": 3.296665869, "cost": 0.6593331738},
"thisWeek": {"value": 17.509996085, "cost": 3.5019992170000003},
"thisMonth": {"value": 103.28830788, "cost": 20.657661576000002},
"thisYear": {"value": 672.9781177300001, "cost": 134.595623546},
},
"electricityIn": {
"measurement": {
"time": "2020-11-18T15:17:24.000Z",
"rate": 1011.6666666666667,
"value": 0.0033333333333333335,
"costPerHour": 0.20233333333333337,
"counterValue": 409.17166666631937,
},
"thisDay": {"value": 2.669999453, "cost": 0.5339998906},
"thisWeek": {"value": 15.328330291, "cost": 3.0656660582},
"thisMonth": {"value": 72.986651896, "cost": 14.5973303792},
"thisYear": {"value": 409.214880212, "cost": 81.84297604240001},
},
"electricityInLow": {
"measurement": None,
"thisDay": {"value": 0.6266664160000001, "cost": 0.1253332832},
"thisWeek": {"value": 2.181665794, "cost": 0.43633315880000006},
"thisMonth": {"value": 30.301655984000003, "cost": 6.060331196800001},
"thisYear": {"value": 263.76323751800004, "cost": 52.75264750360001},
},
"electricityOut": {
"measurement": None,
"thisDay": {"value": 0.0, "cost": 0.0},
"thisWeek": {"value": 0.0, "cost": 0.0},
"thisMonth": {"value": 0.0, "cost": 0.0},
"thisYear": {"value": 0.0, "cost": 0.0},
},
"electricityOutLow": {
"measurement": None,
"thisDay": {"value": 0.0, "cost": 0.0},
"thisWeek": {"value": 0.0, "cost": 0.0},
"thisMonth": {"value": 0.0, "cost": 0.0},
"thisYear": {"value": 0.0, "cost": 0.0},
},
"gas": {
"measurement": {
"time": "2020-11-18T15:17:29.000Z",
"rate": 0.0,
"value": 0.0,
"costPerHour": 0.0,
"counterValue": 116.73000000002281,
},
"thisDay": {"value": 1.07, "cost": 0.642},
"thisWeek": {"value": 5.634224386000001, "cost": 3.3805346316000007},
"thisMonth": {"value": 39.14, "cost": 23.483999999999998},
"thisYear": {"value": 116.73, "cost": 70.038},
},
}
MOCK_LIMITED_CURRENT_MEASUREMENTS = {
"electricity": {
"measurement": {
"time": "2020-11-18T15:17:24.000Z",
"rate": 1011.6666666666667,
"value": 0.0033333333333333335,
"costPerHour": 0.20233333333333337,
"counterValue": 409.17166666631937,
},
"thisDay": {"value": 3.296665869, "cost": 0.6593331738},
"thisWeek": {"value": 17.509996085, "cost": 3.5019992170000003},
"thisMonth": {"value": 103.28830788, "cost": 20.657661576000002},
"thisYear": {"value": 672.9781177300001, "cost": 134.595623546},
}
}
tests/components/huisbaasje/test_init.py
+153
View File
@@ -0,0 +1,153 @@
"""Test cases for the initialisation of the Huisbaasje integration."""
from unittest.mock import patch
from huisbaasje import HuisbaasjeException
from homeassistant.components import huisbaasje
from homeassistant.config_entries import (
CONN_CLASS_CLOUD_POLL,
ENTRY_STATE_LOADED,
ENTRY_STATE_NOT_LOADED,
ENTRY_STATE_SETUP_ERROR,
ConfigEntry,
)
from homeassistant.const import CONF_ID, CONF_PASSWORD, CONF_USERNAME
from homeassistant.core import HomeAssistant
from homeassistant.setup import async_setup_component
from tests.components.huisbaasje.test_data import MOCK_CURRENT_MEASUREMENTS
async def test_setup(hass: HomeAssistant):
"""Test for successfully setting up the platform."""
assert await async_setup_component(hass, huisbaasje.DOMAIN, {})
await hass.async_block_till_done()
assert huisbaasje.DOMAIN in hass.config.components
async def test_setup_entry(hass: HomeAssistant):
"""Test for successfully setting a config entry."""
with patch(
"huisbaasje.Huisbaasje.authenticate", return_value=None
) as mock_authenticate, patch(
"huisbaasje.Huisbaasje.is_authenticated", return_value=True
) as mock_is_authenticated, patch(
"huisbaasje.Huisbaasje.current_measurements",
return_value=MOCK_CURRENT_MEASUREMENTS,
) as mock_current_measurements:
hass.config.components.add(huisbaasje.DOMAIN)
config_entry = ConfigEntry(
1,
huisbaasje.DOMAIN,
"userId",
{
CONF_ID: "userId",
CONF_USERNAME: "username",
CONF_PASSWORD: "password",
},
"test",
CONN_CLASS_CLOUD_POLL,
system_options={},
)
hass.config_entries._entries.append(config_entry)
assert config_entry.state == ENTRY_STATE_NOT_LOADED
assert await hass.config_entries.async_setup(config_entry.entry_id)
await hass.async_block_till_done()
# Assert integration is loaded
assert config_entry.state == ENTRY_STATE_LOADED
assert huisbaasje.DOMAIN in hass.config.components
assert huisbaasje.DOMAIN in hass.data
assert config_entry.entry_id in hass.data[huisbaasje.DOMAIN]
# Assert entities are loaded
entities = hass.states.async_entity_ids("sensor")
assert len(entities) == 14
# Assert mocks are called
assert len(mock_authenticate.mock_calls) == 1
assert len(mock_is_authenticated.mock_calls) == 1
assert len(mock_current_measurements.mock_calls) == 1
async def test_setup_entry_error(hass: HomeAssistant):
"""Test for successfully setting a config entry."""
with patch(
"huisbaasje.Huisbaasje.authenticate", side_effect=HuisbaasjeException
) as mock_authenticate:
hass.config.components.add(huisbaasje.DOMAIN)
config_entry = ConfigEntry(
1,
huisbaasje.DOMAIN,
"userId",
{
CONF_ID: "userId",
CONF_USERNAME: "username",
CONF_PASSWORD: "password",
},
"test",
CONN_CLASS_CLOUD_POLL,
system_options={},
)
hass.config_entries._entries.append(config_entry)
assert config_entry.state == ENTRY_STATE_NOT_LOADED
await hass.config_entries.async_setup(config_entry.entry_id)
await hass.async_block_till_done()
# Assert integration is loaded with error
assert config_entry.state == ENTRY_STATE_SETUP_ERROR
assert huisbaasje.DOMAIN not in hass.data
# Assert entities are not loaded
entities = hass.states.async_entity_ids("sensor")
assert len(entities) == 0
# Assert mocks are called
assert len(mock_authenticate.mock_calls) == 1
async def test_unload_entry(hass: HomeAssistant):
"""Test for successfully unloading the config entry."""
with patch(
"huisbaasje.Huisbaasje.authenticate", return_value=None
) as mock_authenticate, patch(
"huisbaasje.Huisbaasje.is_authenticated", return_value=True
) as mock_is_authenticated, patch(
"huisbaasje.Huisbaasje.current_measurements",
return_value=MOCK_CURRENT_MEASUREMENTS,
) as mock_current_measurements:
hass.config.components.add(huisbaasje.DOMAIN)
config_entry = ConfigEntry(
1,
huisbaasje.DOMAIN,
"userId",
{
CONF_ID: "userId",
CONF_USERNAME: "username",
CONF_PASSWORD: "password",
},
"test",
CONN_CLASS_CLOUD_POLL,
system_options={},
)
hass.config_entries._entries.append(config_entry)
# Load config entry
assert await hass.config_entries.async_setup(config_entry.entry_id)
await hass.async_block_till_done()
assert config_entry.state == ENTRY_STATE_LOADED
entities = hass.states.async_entity_ids("sensor")
assert len(entities) == 14
# Unload config entry
await hass.config_entries.async_unload(config_entry.entry_id)
assert config_entry.state == ENTRY_STATE_NOT_LOADED
entities = hass.states.async_entity_ids("sensor")
assert len(entities) == 0
# Assert mocks are called
assert len(mock_authenticate.mock_calls) == 1
assert len(mock_is_authenticated.mock_calls) == 1
assert len(mock_current_measurements.mock_calls) == 1
tests/components/huisbaasje/test_sensor.py
+120
View File
@@ -0,0 +1,120 @@
"""Test cases for the sensors of the Huisbaasje integration."""
from unittest.mock import patch
from homeassistant.components import huisbaasje
from homeassistant.config_entries import CONN_CLASS_CLOUD_POLL, ConfigEntry
from homeassistant.const import CONF_ID, CONF_PASSWORD, CONF_USERNAME
from homeassistant.core import HomeAssistant
from tests.components.huisbaasje.test_data import (
MOCK_CURRENT_MEASUREMENTS,
MOCK_LIMITED_CURRENT_MEASUREMENTS,
)
async def test_setup_entry(hass: HomeAssistant):
"""Test for successfully loading sensor states."""
with patch(
"huisbaasje.Huisbaasje.authenticate", return_value=None
) as mock_authenticate, patch(
"huisbaasje.Huisbaasje.is_authenticated", return_value=True
) as mock_is_authenticated, patch(
"huisbaasje.Huisbaasje.current_measurements",
return_value=MOCK_CURRENT_MEASUREMENTS,
) as mock_current_measurements:
hass.config.components.add(huisbaasje.DOMAIN)
config_entry = ConfigEntry(
1,
huisbaasje.DOMAIN,
"userId",
{
CONF_ID: "userId",
CONF_USERNAME: "username",
CONF_PASSWORD: "password",
},
"test",
CONN_CLASS_CLOUD_POLL,
system_options={},
)
hass.config_entries._entries.append(config_entry)
assert await hass.config_entries.async_setup(config_entry.entry_id)
await hass.async_block_till_done()
# Assert data is loaded
assert hass.states.get("sensor.huisbaasje_current_power").state == "1012.0"
assert hass.states.get("sensor.huisbaasje_current_power_in").state == "1012.0"
assert (
hass.states.get("sensor.huisbaasje_current_power_in_low").state == "unknown"
)
assert hass.states.get("sensor.huisbaasje_current_power_out").state == "unknown"
assert (
hass.states.get("sensor.huisbaasje_current_power_out_low").state
== "unknown"
)
assert hass.states.get("sensor.huisbaasje_current_gas").state == "0.0"
assert hass.states.get("sensor.huisbaasje_energy_today").state == "3.3"
assert hass.states.get("sensor.huisbaasje_energy_this_week").state == "17.5"
assert hass.states.get("sensor.huisbaasje_energy_this_month").state == "103.3"
assert hass.states.get("sensor.huisbaasje_energy_this_year").state == "673.0"
assert hass.states.get("sensor.huisbaasje_gas_today").state == "1.1"
assert hass.states.get("sensor.huisbaasje_gas_this_week").state == "5.6"
assert hass.states.get("sensor.huisbaasje_gas_this_month").state == "39.1"
assert hass.states.get("sensor.huisbaasje_gas_this_year").state == "116.7"
# Assert mocks are called
assert len(mock_authenticate.mock_calls) == 1
assert len(mock_is_authenticated.mock_calls) == 1
assert len(mock_current_measurements.mock_calls) == 1
async def test_setup_entry_absent_measurement(hass: HomeAssistant):
"""Test for successfully loading sensor states when response does not contain all measurements."""
with patch(
"huisbaasje.Huisbaasje.authenticate", return_value=None
) as mock_authenticate, patch(
"huisbaasje.Huisbaasje.is_authenticated", return_value=True
) as mock_is_authenticated, patch(
"huisbaasje.Huisbaasje.current_measurements",
return_value=MOCK_LIMITED_CURRENT_MEASUREMENTS,
) as mock_current_measurements:
hass.config.components.add(huisbaasje.DOMAIN)
config_entry = ConfigEntry(
1,
huisbaasje.DOMAIN,
"userId",
{
CONF_ID: "userId",
CONF_USERNAME: "username",
CONF_PASSWORD: "password",
},
"test",
CONN_CLASS_CLOUD_POLL,
system_options={},
)
hass.config_entries._entries.append(config_entry)
assert await hass.config_entries.async_setup(config_entry.entry_id)
await hass.async_block_till_done()
# Assert data is loaded
assert hass.states.get("sensor.huisbaasje_current_power").state == "1012.0"
assert hass.states.get("sensor.huisbaasje_current_power_in").state == "unknown"
assert (
hass.states.get("sensor.huisbaasje_current_power_in_low").state == "unknown"
)
assert hass.states.get("sensor.huisbaasje_current_power_out").state == "unknown"
assert (
hass.states.get("sensor.huisbaasje_current_power_out_low").state
== "unknown"
)
assert hass.states.get("sensor.huisbaasje_current_gas").state == "unknown"
assert hass.states.get("sensor.huisbaasje_energy_today").state == "3.3"
assert hass.states.get("sensor.huisbaasje_gas_today").state == "unknown"
# Assert mocks are called
assert len(mock_authenticate.mock_calls) == 1
assert len(mock_is_authenticated.mock_calls) == 1
assert len(mock_current_measurements.mock_calls) == 1