mirror of
https://github.com/home-assistant/core.git
synced 2025-08-12 06:50:00 +00:00
.devcontainer
.github
.vscode
docs
homeassistant
machine
pylint
rootfs
script
tests
auth
backports
components
abode
accuweather
acmeda
adax
adguard
advantage_air
aemet
agent_dvr
air_quality
airly
airnow
airq
airthings
airthings_ble
airtouch4
airvisual
airvisual_pro
airzone
aladdin_connect
alarm_control_panel
alarmdecoder
alert
alexa
almond
amberelectric
ambiclimate
ambient_station
analytics
android_ip_webcam
androidtv
anthemav
apache_kafka
apcupsd
api
api_streams
apple_tv
application_credentials
apprise
aprs
aranet
arcam_fmj
aseko_pool_live
asuswrt
atag
august
aurora
aurora_abb_powerone
aussie_broadband
auth
automation
awair
aws
axis
azure_devops
azure_event_hub
backup
baf
balboa
bayesian
binary_sensor
blackbird
blebox
blink
bluemaestro
blueprint
bluetooth
bluetooth_le_tracker
bmw_connected_drive
bond
bosch_shc
braviatv
broadlink
brother
brunt
bsblan
bthome
buienradar
button
caldav
calendar
camera
canary
cast
cert_expiry
clicksend_tts
climate
cloud
cloudflare
co2signal
coinbase
color_extractor
comfoconnect
command_line
compensation
config
configurator
control4
conversation
coolmaster
coronavirus
counter
cover
cpuspeed
crownstone
daikin
darksky
datadog
debugpy
deconz
default_config
deluge
demo
denonavr
derivative
device_automation
device_sun_light_trigger
device_tracker
devolo_home_control
devolo_home_network
dexcom
dhcp
diagnostics
dialogflow
directv
discord
discovery
dlna_dmr
dlna_dms
dnsip
doorbird
dsmr
dsmr_reader
dte_energy_bridge
duckdns
dunehd
dynalite
eafm
ecobee
econet
ecowitt
efergy
eight_sleep
elgato
elkm1
elmax
emonitor
emulated_hue
emulated_kasa
emulated_roku
energy
enocean
enphase_envoy
environment_canada
epson
escea
esphome
everlights
evil_genius_labs
ezviz
faa_delays
facebook
facebox
fail2ban
fan
feedreader
ffmpeg
fibaro
fido
file
file_upload
filesize
filter
fireservicerota
firmata
fivem
fjaraskupan
flic
flick_electric
flipr
flo
flume
flux
flux_led
folder
folder_watcher
foobot
forecast_solar
forked_daapd
foscam
freebox
freedns
freedompro
fritz
fritzbox
fritzbox_callmonitor
fronius
frontend
fully_kiosk
garages_amsterdam
gdacs
generic
generic_hygrostat
generic_thermostat
geo_json_events
geo_location
geo_rss_events
geocaching
geofency
geonetnz_quakes
geonetnz_volcano
gios
github
glances
goalzero
gogogate2
goodwe
google
google_assistant
google_assistant_sdk
google_domains
google_pubsub
google_sheets
google_translate
google_travel_time
google_wifi
govee_ble
gpslogger
graphite
gree
greeneye_monitor
group
growatt_server
guardian
habitica
hardkernel
hardware
harmony
hassio
hddtemp
hdmi_cec
heos
here_travel_time
hisense_aehw4a1
history
history_stats
hive
hlk_sw16
home_connect
home_plus_control
homeassistant
homeassistant_alerts
homeassistant_hardware
homeassistant_sky_connect
homeassistant_yellow
homekit
homekit_controller
homematic
homematicip_cloud
homewizard
honeywell
html5
http
huawei_lte
hue
huisbaasje
humidifier
hunterdouglas_powerview
hvv_departures
hyperion
ialarm
iaqualink
ibeacon
icloud
ifttt
ign_sismologia
image_processing
image_upload
imap_email_content
influxdb
inkbird
input_boolean
input_button
input_datetime
input_number
input_select
input_text
insteon
integration
intellifire
intent
intent_script
ios
iotawatt
ipma
ipp
iqvia
islamic_prayer_times
iss
isy994
izone
jellyfin
jewish_calendar
juicenet
justnimbus
kaleidescape
keenetic_ndms2
kegtron
keymitt_ble
kira
kmtronic
knx
kodi
konnected
kostal_plenticore
kraken
kulersky
lacrosse_view
lametric
landisgyr_heat_meter
lastfm
launch_library
laundrify
lcn
led_ble
lg_soundbar
lidarr
life360
lifx
light
litejet
litterrobot
livisi
local_calendar
local_file
local_ip
locative
lock
logbook
logentries
logger
logi_circle
london_air
lookin
lovelace
luftdaten
lutron_caseta
lyric
mailbox
mailgun
manual
manual_mqtt
marytts
matter
maxcube
mazda
meater
media_player
media_source
melcloud
melissa
melnor
meraki
met
met_eireann
meteo_france
meteoclimatic
metoffice
mfi
microsoft_face
microsoft_face_detect
microsoft_face_identify
mikrotik
mill
min_max
minecraft_server
minio
mjpeg
moat
mobile_app
mochad
modbus
modem_callerid
modern_forms
moehlenhoff_alpha2
mold_indicator
monoprice
moon
motion_blinds
motioneye
mqtt
mqtt_eventstream
mqtt_json
mqtt_room
mqtt_statestream
mullvad
mutesync
my
myq
mysensors
mythicbeastsdns
nam
namecheapdns
nanoleaf
neato
ness_alarm
nest
netatmo
netgear
network
nexia
nextbus
nextdns
nfandroidtv
nibe_heatpump
nightscout
nina
nmap_tracker
no_ip
nobo_hub
notify
notify_events
notion
nsw_fuel_station
nsw_rural_fire_service_feed
nuheat
nuki
numato
number
nut
nws
nx584
nzbget
octoprint
omnilogic
onboarding
oncue
ondilo_ico
onewire
onvif
open_meteo
openalpr_cloud
openerz
openexchangerates
opengarage
openhardwaremonitor
opentherm_gw
openuv
openweathermap
opnsense
oralb
overkiz
ovo_energy
owntracks
p1_monitor
panasonic_viera
panel_custom
panel_iframe
peco
persistent_notification
person
philips_js
pi_hole
picnic
pilight
ping
plaato
plant
plex
plugwise
plum_lightpad
point
poolsense
powerwall
profiler
progettihwsw
prometheus
prosegur
proximity
prusalink
ps4
pure_energie
purpleair
push
pushbullet
pushover
pvoutput
pvpc_hourly_pricing
python_script
qingping
qld_bushfire
qnap_qsw
qwikswitch
rachio
radarr
radio_browser
radiotherm
rainbird
rainforest_eagle
rainmachine
random
raspberry_pi
rdw
recollect_waste
recorder
reddit
remember_the_milk
remote
renault
reolink
repairs
rest
rest_command
rflink
rfxtrx
rhasspy
ridwell
ring
risco
rituals_perfume_genie
rmvtransport
roku
roomba
roon
rpi_power
rss_feed_template
rtsp_to_webrtc
ruckus_unleashed
ruuvitag_ble
sabnzbd
safe_mode
samsungtv
scene
schedule
scrape
screenlogic
script
search
season
select
sense
senseme
sensibo
sensirion_ble
sensor
sensorpro
sensorpush
sentry
senz
seventeentrack
sfr_box
sharkiq
shell_command
shelly
shopping_list
sia
sigfox
sighthound
signal_messenger
simplepush
simplisafe
simulated
siren
skybell
slack
sleepiq
slimproto
sma
smappee
smart_meter_texas
smartthings
smarttub
smhi
smtp
snips
snmp
snooz
solaredge
solarlog
solax
soma
somfy_mylink
sonarr
songpal
sonos
soundtouch
spaceapi
spc
speedtestdotnet
spider
spotify
sql
squeezebox
srp_energy
ssdp
starline
startca
statistics
statsd
steam_online
steamist
stookalert
stream
stt
subaru
sun
surepetcare
switch
switch_as_x
switchbee
switchbot
switcher_kis
syncthing
syncthru
synology_dsm
system_bridge
system_health
system_log
tado
tag
tailscale
tankerkoenig
tasmota
tautulli
tcp
telegram
telegram_bot
tellduslive
template
tesla_wall_connector
text
thermobeacon
thermopro
threshold
tibber
tile
tilt_ble
time_date
timer
tod
todoist
tolo
tomato
tomorrowio
toon
totalconnect
tplink
traccar
trace
tractive
tradfri
trafikverket_ferry
trafikverket_train
trafikverket_weatherstation
transmission
transport_nsw
trend
tts
tuya
twentemilieu
twilio
twinkly
twitch
uk_transport
ukraine_alarm
unifi
unifi_direct
unifiprotect
universal
upb
upcloud
update
upnp
uptime
uptimerobot
usb
usgs_earthquakes_feed
utility_meter
__init__.py
test_config_flow.py
test_init.py
test_sensor.py
uvc
vacuum
vallox
velbus
venstar
vera
verisure
version
vesync
vicare
vilfo
vizio
vlc_telnet
voicerss
volumio
volvooncall
vulcan
vultr
wake_on_lan
wallbox
water_heater
watttime
waze_travel_time
weather
webhook
webostv
websocket_api
wemo
whirlpool
whois
wiffi
wilight
withings
wiz
wled
wolflink
workday
worldclock
ws66i
wsdot
xbox
xiaomi
xiaomi_aqara
xiaomi_ble
xiaomi_miio
yale_smart_alarm
yalexs_ble
yamaha
yamaha_musiccast
yandex_transport
yandextts
yeelight
yolink
youless
zamg
zeroconf
zerproc
zha
zodiac
zone
zwave_js
zwave_me
__init__.py
conftest.py
fixtures
hassfest
helpers
pylint
resources
scripts
test_util
testing_config
util
__init__.py
bandit.yaml
common.py
conftest.py
ignore_uncaught_exceptions.py
test_bootstrap.py
test_config.py
test_config_entries.py
test_core.py
test_data_entry_flow.py
test_exceptions.py
test_loader.py
test_main.py
test_requirements.py
test_runner.py
test_setup.py
test_test_fixtures.py
.core_files.yaml
.coveragerc
.dockerignore
.gitattributes
.gitignore
.hadolint.yaml
.pre-commit-config.yaml
.prettierignore
.readthedocs.yml
.strict-typing
.yamllint
CLA.md
CODEOWNERS
CODE_OF_CONDUCT.md
CONTRIBUTING.md
Dockerfile
Dockerfile.dev
LICENSE.md
MANIFEST.in
README.rst
build.yaml
codecov.yml
mypy.ini
pyproject.toml
requirements.txt
requirements_all.txt
requirements_docs.txt
requirements_test.txt
requirements_test_all.txt
requirements_test_pre_commit.txt
setup.cfg

* Adjust root-import in tests * Adjust diagnostics * Adjust button * Adjust select * Adjust device_tracker * Adjust camera * Adjust humidifier * Adjust media_source * Adjust update * Adjust siren * Adjust number * Adjust alarm_control_panel * Adjust notify * Adjust sensor * Adjust switch * Revert anthemav * Don't adjust demo humidifier
438 lines
13 KiB
Python
438 lines
13 KiB
Python
"""The tests for the utility_meter component."""
|
|
from __future__ import annotations
|
|
|
|
from datetime import timedelta
|
|
from unittest.mock import patch
|
|
|
|
import pytest
|
|
|
|
from homeassistant.components.select import (
|
|
ATTR_OPTION,
|
|
DOMAIN as SELECT_DOMAIN,
|
|
SERVICE_SELECT_OPTION,
|
|
)
|
|
from homeassistant.components.utility_meter.const import DOMAIN, SERVICE_RESET
|
|
import homeassistant.components.utility_meter.select as um_select
|
|
import homeassistant.components.utility_meter.sensor as um_sensor
|
|
from homeassistant.const import (
|
|
ATTR_ENTITY_ID,
|
|
ATTR_UNIT_OF_MEASUREMENT,
|
|
CONF_PLATFORM,
|
|
ENERGY_KILO_WATT_HOUR,
|
|
EVENT_HOMEASSISTANT_START,
|
|
Platform,
|
|
)
|
|
from homeassistant.core import HomeAssistant, State
|
|
from homeassistant.helpers import entity_registry as er
|
|
from homeassistant.setup import async_setup_component
|
|
import homeassistant.util.dt as dt_util
|
|
|
|
from tests.common import MockConfigEntry, mock_restore_cache
|
|
|
|
|
|
async def test_restore_state(hass):
|
|
"""Test utility sensor restore state."""
|
|
config = {
|
|
"utility_meter": {
|
|
"energy_bill": {
|
|
"source": "sensor.energy",
|
|
"tariffs": ["onpeak", "midpeak", "offpeak"],
|
|
}
|
|
}
|
|
}
|
|
mock_restore_cache(
|
|
hass,
|
|
[
|
|
State(
|
|
"select.energy_bill",
|
|
"midpeak",
|
|
),
|
|
],
|
|
)
|
|
|
|
assert await async_setup_component(hass, DOMAIN, config)
|
|
assert await async_setup_component(hass, Platform.SENSOR, config)
|
|
await hass.async_block_till_done()
|
|
|
|
# restore from cache
|
|
state = hass.states.get("select.energy_bill")
|
|
assert state.state == "midpeak"
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"meter",
|
|
(
|
|
["select.energy_bill"],
|
|
"select.energy_bill",
|
|
),
|
|
)
|
|
async def test_services(hass, meter):
|
|
"""Test energy sensor reset service."""
|
|
config = {
|
|
"utility_meter": {
|
|
"energy_bill": {
|
|
"source": "sensor.energy",
|
|
"cycle": "hourly",
|
|
"tariffs": ["peak", "offpeak"],
|
|
},
|
|
"energy_bill2": {
|
|
"source": "sensor.energy",
|
|
"cycle": "hourly",
|
|
"tariffs": ["peak", "offpeak"],
|
|
},
|
|
}
|
|
}
|
|
|
|
assert await async_setup_component(hass, DOMAIN, config)
|
|
assert await async_setup_component(hass, Platform.SENSOR, config)
|
|
await hass.async_block_till_done()
|
|
|
|
hass.bus.async_fire(EVENT_HOMEASSISTANT_START)
|
|
entity_id = config[DOMAIN]["energy_bill"]["source"]
|
|
hass.states.async_set(
|
|
entity_id, 1, {ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR}
|
|
)
|
|
await hass.async_block_till_done()
|
|
|
|
now = dt_util.utcnow() + timedelta(seconds=10)
|
|
with patch("homeassistant.util.dt.utcnow", return_value=now):
|
|
hass.states.async_set(
|
|
entity_id,
|
|
3,
|
|
{ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR},
|
|
force_update=True,
|
|
)
|
|
await hass.async_block_till_done()
|
|
|
|
state = hass.states.get("sensor.energy_bill_peak")
|
|
assert state.state == "2"
|
|
|
|
state = hass.states.get("sensor.energy_bill_offpeak")
|
|
assert state.state == "0"
|
|
|
|
# Change tariff
|
|
data = {ATTR_ENTITY_ID: "select.energy_bill", ATTR_OPTION: "offpeak"}
|
|
await hass.services.async_call(SELECT_DOMAIN, SERVICE_SELECT_OPTION, data)
|
|
await hass.async_block_till_done()
|
|
|
|
now += timedelta(seconds=10)
|
|
with patch("homeassistant.util.dt.utcnow", return_value=now):
|
|
hass.states.async_set(
|
|
entity_id,
|
|
4,
|
|
{ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR},
|
|
force_update=True,
|
|
)
|
|
await hass.async_block_till_done()
|
|
|
|
state = hass.states.get("sensor.energy_bill_peak")
|
|
assert state.state == "2"
|
|
|
|
state = hass.states.get("sensor.energy_bill_offpeak")
|
|
assert state.state == "1"
|
|
|
|
# Change tariff
|
|
data = {ATTR_ENTITY_ID: "select.energy_bill", "option": "wrong_tariff"}
|
|
await hass.services.async_call(SELECT_DOMAIN, SERVICE_SELECT_OPTION, data)
|
|
await hass.async_block_till_done()
|
|
|
|
# Inexisting tariff, ignoring
|
|
assert hass.states.get("select.energy_bill").state != "wrong_tariff"
|
|
|
|
data = {ATTR_ENTITY_ID: "select.energy_bill", "option": "peak"}
|
|
await hass.services.async_call(SELECT_DOMAIN, SERVICE_SELECT_OPTION, data)
|
|
await hass.async_block_till_done()
|
|
|
|
now += timedelta(seconds=10)
|
|
with patch("homeassistant.util.dt.utcnow", return_value=now):
|
|
hass.states.async_set(
|
|
entity_id,
|
|
5,
|
|
{ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR},
|
|
force_update=True,
|
|
)
|
|
await hass.async_block_till_done()
|
|
|
|
state = hass.states.get("sensor.energy_bill_peak")
|
|
assert state.state == "3"
|
|
|
|
state = hass.states.get("sensor.energy_bill_offpeak")
|
|
assert state.state == "1"
|
|
|
|
# Reset meters
|
|
data = {ATTR_ENTITY_ID: meter}
|
|
await hass.services.async_call(DOMAIN, SERVICE_RESET, data)
|
|
await hass.async_block_till_done()
|
|
|
|
state = hass.states.get("sensor.energy_bill_peak")
|
|
assert state.state == "0"
|
|
|
|
state = hass.states.get("sensor.energy_bill_offpeak")
|
|
assert state.state == "0"
|
|
|
|
# meanwhile energy_bill2_peak accumulated all kWh
|
|
state = hass.states.get("sensor.energy_bill2_peak")
|
|
assert state.state == "4"
|
|
|
|
|
|
async def test_services_config_entry(hass):
|
|
"""Test energy sensor reset service."""
|
|
config_entry = MockConfigEntry(
|
|
data={},
|
|
domain=DOMAIN,
|
|
options={
|
|
"cycle": "monthly",
|
|
"delta_values": False,
|
|
"name": "Energy bill",
|
|
"net_consumption": False,
|
|
"offset": 0,
|
|
"source": "sensor.energy",
|
|
"tariffs": ["peak", "offpeak"],
|
|
},
|
|
title="Energy bill",
|
|
)
|
|
config_entry.add_to_hass(hass)
|
|
assert await hass.config_entries.async_setup(config_entry.entry_id)
|
|
config_entry = MockConfigEntry(
|
|
data={},
|
|
domain=DOMAIN,
|
|
options={
|
|
"cycle": "monthly",
|
|
"delta_values": False,
|
|
"name": "Energy bill2",
|
|
"net_consumption": False,
|
|
"offset": 0,
|
|
"source": "sensor.energy",
|
|
"tariffs": ["peak", "offpeak"],
|
|
},
|
|
title="Energy bill2",
|
|
)
|
|
config_entry.add_to_hass(hass)
|
|
assert await hass.config_entries.async_setup(config_entry.entry_id)
|
|
await hass.async_block_till_done()
|
|
|
|
hass.bus.async_fire(EVENT_HOMEASSISTANT_START)
|
|
entity_id = "sensor.energy"
|
|
hass.states.async_set(
|
|
entity_id, 1, {ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR}
|
|
)
|
|
await hass.async_block_till_done()
|
|
|
|
now = dt_util.utcnow() + timedelta(seconds=10)
|
|
with patch("homeassistant.util.dt.utcnow", return_value=now):
|
|
hass.states.async_set(
|
|
entity_id,
|
|
3,
|
|
{ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR},
|
|
force_update=True,
|
|
)
|
|
await hass.async_block_till_done()
|
|
|
|
state = hass.states.get("sensor.energy_bill_peak")
|
|
assert state.state == "2"
|
|
|
|
state = hass.states.get("sensor.energy_bill_offpeak")
|
|
assert state.state == "0"
|
|
|
|
# Change tariff
|
|
data = {ATTR_ENTITY_ID: "select.energy_bill", "option": "offpeak"}
|
|
await hass.services.async_call(SELECT_DOMAIN, SERVICE_SELECT_OPTION, data)
|
|
await hass.async_block_till_done()
|
|
|
|
now += timedelta(seconds=10)
|
|
with patch("homeassistant.util.dt.utcnow", return_value=now):
|
|
hass.states.async_set(
|
|
entity_id,
|
|
4,
|
|
{ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR},
|
|
force_update=True,
|
|
)
|
|
await hass.async_block_till_done()
|
|
|
|
state = hass.states.get("sensor.energy_bill_peak")
|
|
assert state.state == "2"
|
|
|
|
state = hass.states.get("sensor.energy_bill_offpeak")
|
|
assert state.state == "1"
|
|
|
|
# Change tariff
|
|
data = {ATTR_ENTITY_ID: "select.energy_bill", "option": "wrong_tariff"}
|
|
await hass.services.async_call(SELECT_DOMAIN, SERVICE_SELECT_OPTION, data)
|
|
await hass.async_block_till_done()
|
|
|
|
# Inexisting tariff, ignoring
|
|
assert hass.states.get("select.energy_bill").state != "wrong_tariff"
|
|
|
|
data = {ATTR_ENTITY_ID: "select.energy_bill", "option": "peak"}
|
|
await hass.services.async_call(SELECT_DOMAIN, SERVICE_SELECT_OPTION, data)
|
|
await hass.async_block_till_done()
|
|
|
|
now += timedelta(seconds=10)
|
|
with patch("homeassistant.util.dt.utcnow", return_value=now):
|
|
hass.states.async_set(
|
|
entity_id,
|
|
5,
|
|
{ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR},
|
|
force_update=True,
|
|
)
|
|
await hass.async_block_till_done()
|
|
|
|
state = hass.states.get("sensor.energy_bill_peak")
|
|
assert state.state == "3"
|
|
|
|
state = hass.states.get("sensor.energy_bill_offpeak")
|
|
assert state.state == "1"
|
|
|
|
# Reset meters
|
|
data = {ATTR_ENTITY_ID: "select.energy_bill"}
|
|
await hass.services.async_call(DOMAIN, SERVICE_RESET, data)
|
|
await hass.async_block_till_done()
|
|
|
|
state = hass.states.get("sensor.energy_bill_peak")
|
|
assert state.state == "0"
|
|
|
|
state = hass.states.get("sensor.energy_bill_offpeak")
|
|
assert state.state == "0"
|
|
|
|
# meanwhile energy_bill2_peak accumulated all kWh
|
|
state = hass.states.get("sensor.energy_bill2_peak")
|
|
assert state.state == "4"
|
|
|
|
|
|
async def test_cron(hass):
|
|
"""Test cron pattern."""
|
|
|
|
config = {
|
|
"utility_meter": {
|
|
"energy_bill": {
|
|
"source": "sensor.energy",
|
|
"cron": "*/5 * * * *",
|
|
}
|
|
}
|
|
}
|
|
|
|
assert await async_setup_component(hass, DOMAIN, config)
|
|
|
|
|
|
async def test_cron_and_meter(hass):
|
|
"""Test cron pattern and meter type fails."""
|
|
config = {
|
|
"utility_meter": {
|
|
"energy_bill": {
|
|
"source": "sensor.energy",
|
|
"cycle": "hourly",
|
|
"cron": "0 0 1 * *",
|
|
}
|
|
}
|
|
}
|
|
|
|
assert not await async_setup_component(hass, DOMAIN, config)
|
|
|
|
|
|
async def test_both_cron_and_meter(hass):
|
|
"""Test cron pattern and meter type passes in different meter."""
|
|
config = {
|
|
"utility_meter": {
|
|
"energy_bill": {
|
|
"source": "sensor.energy",
|
|
"cron": "0 0 1 * *",
|
|
},
|
|
"water_bill": {
|
|
"source": "sensor.water",
|
|
"cycle": "hourly",
|
|
},
|
|
}
|
|
}
|
|
|
|
assert await async_setup_component(hass, DOMAIN, config)
|
|
|
|
|
|
async def test_cron_and_offset(hass):
|
|
"""Test cron pattern and offset fails."""
|
|
|
|
config = {
|
|
"utility_meter": {
|
|
"energy_bill": {
|
|
"source": "sensor.energy",
|
|
"offset": {"days": 1},
|
|
"cron": "0 0 1 * *",
|
|
}
|
|
}
|
|
}
|
|
|
|
assert not await async_setup_component(hass, DOMAIN, config)
|
|
|
|
|
|
async def test_bad_cron(hass):
|
|
"""Test bad cron pattern."""
|
|
|
|
config = {
|
|
"utility_meter": {"energy_bill": {"source": "sensor.energy", "cron": "*"}}
|
|
}
|
|
|
|
assert not await async_setup_component(hass, DOMAIN, config)
|
|
|
|
|
|
async def test_setup_missing_discovery(hass):
|
|
"""Test setup with configuration missing discovery_info."""
|
|
assert not await um_select.async_setup_platform(hass, {CONF_PLATFORM: DOMAIN}, None)
|
|
assert not await um_sensor.async_setup_platform(hass, {CONF_PLATFORM: DOMAIN}, None)
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"tariffs,expected_entities",
|
|
(
|
|
(
|
|
[],
|
|
["sensor.electricity_meter"],
|
|
),
|
|
(
|
|
["high", "low"],
|
|
[
|
|
"sensor.electricity_meter_low",
|
|
"sensor.electricity_meter_high",
|
|
"select.electricity_meter",
|
|
],
|
|
),
|
|
),
|
|
)
|
|
async def test_setup_and_remove_config_entry(
|
|
hass: HomeAssistant, tariffs: str, expected_entities: list[str]
|
|
) -> None:
|
|
"""Test setting up and removing a config entry."""
|
|
input_sensor_entity_id = "sensor.input"
|
|
registry = er.async_get(hass)
|
|
|
|
# Setup the config entry
|
|
config_entry = MockConfigEntry(
|
|
data={},
|
|
domain=DOMAIN,
|
|
options={
|
|
"cycle": "monthly",
|
|
"delta_values": False,
|
|
"name": "Electricity meter",
|
|
"net_consumption": False,
|
|
"offset": 0,
|
|
"source": input_sensor_entity_id,
|
|
"tariffs": tariffs,
|
|
},
|
|
title="Electricity meter",
|
|
)
|
|
config_entry.add_to_hass(hass)
|
|
assert await hass.config_entries.async_setup(config_entry.entry_id)
|
|
await hass.async_block_till_done()
|
|
|
|
assert len(hass.states.async_all()) == len(expected_entities)
|
|
assert len(registry.entities) == len(expected_entities)
|
|
for entity in expected_entities:
|
|
assert hass.states.get(entity)
|
|
assert entity in registry.entities
|
|
|
|
# Remove the config entry
|
|
assert await hass.config_entries.async_remove(config_entry.entry_id)
|
|
await hass.async_block_till_done()
|
|
|
|
# Check the state and entity registry entry are removed
|
|
assert len(hass.states.async_all()) == 0
|
|
assert len(registry.entities) == 0
|