evlli/hass-core
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Black

Browse source
This commit is contained in:
Paulus Schoutsen 2019-07-31 12:25:30 -07:00
parent da05dfe708
commit 4de97abc3a
2676 changed files with 163166 additions and 140084 deletions
Download patch file Download diff file Expand all files Collapse all files

161
tests/components/integration/test_sensor.py
View file

@ -9,200 +9,195 @@ import homeassistant.util.dt as dt_util
async def test_state(hass):
"""Test integration sensor state."""
config = {
'sensor': {
'platform': 'integration',
'name': 'integration',
'source': 'sensor.power',
'unit': 'kWh',
'round': 2,
"sensor": {
"platform": "integration",
"name": "integration",
"source": "sensor.power",
"unit": "kWh",
"round": 2,
}
}
assert await async_setup_component(hass, 'sensor', config)
assert await async_setup_component(hass, "sensor", config)
entity_id = config['sensor']['source']
entity_id = config["sensor"]["source"]
hass.states.async_set(entity_id, 1, {})
await hass.async_block_till_done()
now = dt_util.utcnow() + timedelta(seconds=3600)
with patch('homeassistant.util.dt.utcnow',
return_value=now):
with patch("homeassistant.util.dt.utcnow", return_value=now):
hass.states.async_set(entity_id, 1, {}, force_update=True)
await hass.async_block_till_done()
state = hass.states.get('sensor.integration')
state = hass.states.get("sensor.integration")
assert state is not None
# Testing a power sensor at 1 KiloWatts for 1hour = 1kWh
assert round(float(state.state), config['sensor']['round']) == 1.0
assert round(float(state.state), config["sensor"]["round"]) == 1.0
assert state.attributes.get('unit_of_measurement') == 'kWh'
assert state.attributes.get("unit_of_measurement") == "kWh"
async def test_trapezoidal(hass):
"""Test integration sensor state."""
config = {
'sensor': {
'platform': 'integration',
'name': 'integration',
'source': 'sensor.power',
'unit': 'kWh',
'round': 2,
"sensor": {
"platform": "integration",
"name": "integration",
"source": "sensor.power",
"unit": "kWh",
"round": 2,
}
}
assert await async_setup_component(hass, 'sensor', config)
assert await async_setup_component(hass, "sensor", config)
entity_id = config['sensor']['source']
entity_id = config["sensor"]["source"]
hass.states.async_set(entity_id, 0, {})
await hass.async_block_till_done()
# Testing a power sensor with non-monotonic intervals and values
for time, value in [(20, 10), (30, 30), (40, 5), (50, 0)]:
now = dt_util.utcnow() + timedelta(minutes=time)
with patch('homeassistant.util.dt.utcnow',
return_value=now):
with patch("homeassistant.util.dt.utcnow", return_value=now):
hass.states.async_set(entity_id, value, {}, force_update=True)
await hass.async_block_till_done()
state = hass.states.get('sensor.integration')
state = hass.states.get("sensor.integration")
assert state is not None
assert round(float(state.state), config['sensor']['round']) == 8.33
assert round(float(state.state), config["sensor"]["round"]) == 8.33
assert state.attributes.get('unit_of_measurement') == 'kWh'
assert state.attributes.get("unit_of_measurement") == "kWh"
async def test_left(hass):
"""Test integration sensor state with left reimann method."""
config = {
'sensor': {
'platform': 'integration',
'name': 'integration',
'method': 'left',
'source': 'sensor.power',
'unit': 'kWh',
'round': 2,
"sensor": {
"platform": "integration",
"name": "integration",
"method": "left",
"source": "sensor.power",
"unit": "kWh",
"round": 2,
}
}
assert await async_setup_component(hass, 'sensor', config)
assert await async_setup_component(hass, "sensor", config)
entity_id = config['sensor']['source']
entity_id = config["sensor"]["source"]
hass.states.async_set(entity_id, 0, {})
await hass.async_block_till_done()
# Testing a power sensor with non-monotonic intervals and values
for time, value in [(20, 10), (30, 30), (40, 5), (50, 0)]:
now = dt_util.utcnow() + timedelta(minutes=time)
with patch('homeassistant.util.dt.utcnow',
return_value=now):
with patch("homeassistant.util.dt.utcnow", return_value=now):
hass.states.async_set(entity_id, value, {}, force_update=True)
await hass.async_block_till_done()
state = hass.states.get('sensor.integration')
state = hass.states.get("sensor.integration")
assert state is not None
assert round(float(state.state), config['sensor']['round']) == 7.5
assert round(float(state.state), config["sensor"]["round"]) == 7.5
assert state.attributes.get('unit_of_measurement') == 'kWh'
assert state.attributes.get("unit_of_measurement") == "kWh"
async def test_right(hass):
"""Test integration sensor state with left reimann method."""
config = {
'sensor': {
'platform': 'integration',
'name': 'integration',
'method': 'right',
'source': 'sensor.power',
'unit': 'kWh',
'round': 2,
"sensor": {
"platform": "integration",
"name": "integration",
"method": "right",
"source": "sensor.power",
"unit": "kWh",
"round": 2,
}
}
assert await async_setup_component(hass, 'sensor', config)
assert await async_setup_component(hass, "sensor", config)
entity_id = config['sensor']['source']
entity_id = config["sensor"]["source"]
hass.states.async_set(entity_id, 0, {})
await hass.async_block_till_done()
# Testing a power sensor with non-monotonic intervals and values
for time, value in [(20, 10), (30, 30), (40, 5), (50, 0)]:
now = dt_util.utcnow() + timedelta(minutes=time)
with patch('homeassistant.util.dt.utcnow',
return_value=now):
with patch("homeassistant.util.dt.utcnow", return_value=now):
hass.states.async_set(entity_id, value, {}, force_update=True)
await hass.async_block_till_done()
state = hass.states.get('sensor.integration')
state = hass.states.get("sensor.integration")
assert state is not None
assert round(float(state.state), config['sensor']['round']) == 9.17
assert round(float(state.state), config["sensor"]["round"]) == 9.17
assert state.attributes.get('unit_of_measurement') == 'kWh'
assert state.attributes.get("unit_of_measurement") == "kWh"
async def test_prefix(hass):
"""Test integration sensor state using a power source."""
config = {
'sensor': {
'platform': 'integration',
'name': 'integration',
'source': 'sensor.power',
'round': 2,
'unit_prefix': 'k'
"sensor": {
"platform": "integration",
"name": "integration",
"source": "sensor.power",
"round": 2,
"unit_prefix": "k",
}
}
assert await async_setup_component(hass, 'sensor', config)
assert await async_setup_component(hass, "sensor", config)
entity_id = config['sensor']['source']
hass.states.async_set(entity_id, 1000, {'unit_of_measurement': 'W'})
entity_id = config["sensor"]["source"]
hass.states.async_set(entity_id, 1000, {"unit_of_measurement": "W"})
await hass.async_block_till_done()
now = dt_util.utcnow() + timedelta(seconds=3600)
with patch('homeassistant.util.dt.utcnow',
return_value=now):
hass.states.async_set(entity_id, 1000, {'unit_of_measurement': 'W'},
force_update=True)
with patch("homeassistant.util.dt.utcnow", return_value=now):
hass.states.async_set(
entity_id, 1000, {"unit_of_measurement": "W"}, force_update=True
)
await hass.async_block_till_done()
state = hass.states.get('sensor.integration')
state = hass.states.get("sensor.integration")
assert state is not None
# Testing a power sensor at 1000 Watts for 1hour = 1kWh
assert round(float(state.state), config['sensor']['round']) == 1.0
assert state.attributes.get('unit_of_measurement') == 'kWh'
assert round(float(state.state), config["sensor"]["round"]) == 1.0
assert state.attributes.get("unit_of_measurement") == "kWh"
async def test_suffix(hass):
"""Test integration sensor state using a network counter source."""
config = {
'sensor': {
'platform': 'integration',
'name': 'integration',
'source': 'sensor.bytes_per_second',
'round': 2,
'unit_prefix': 'k',
'unit_time': 's'
"sensor": {
"platform": "integration",
"name": "integration",
"source": "sensor.bytes_per_second",
"round": 2,
"unit_prefix": "k",
"unit_time": "s",
}
}
assert await async_setup_component(hass, 'sensor', config)
assert await async_setup_component(hass, "sensor", config)
entity_id = config['sensor']['source']
entity_id = config["sensor"]["source"]
hass.states.async_set(entity_id, 1000, {})
await hass.async_block_till_done()
now = dt_util.utcnow() + timedelta(seconds=10)
with patch('homeassistant.util.dt.utcnow',
return_value=now):
with patch("homeassistant.util.dt.utcnow", return_value=now):
hass.states.async_set(entity_id, 1000, {}, force_update=True)
await hass.async_block_till_done()
state = hass.states.get('sensor.integration')
state = hass.states.get("sensor.integration")
assert state is not None
# Testing a network speed sensor at 1000 bytes/s over 10s = 10kbytes
assert round(float(state.state), config['sensor']['round']) == 10.0
assert round(float(state.state), config["sensor"]["round"]) == 10.0