jeans/core
jeans/core
1
0
Fork 0
mirror of https://github.com/home-assistant/core.git synced 2025-07-23 13:17:32 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rewrite mold_indicator unittest tests to pytest style test functions (#41598)

Browse Source
This commit is contained in:
CurrentThread 2020-10-16 13:37:15 +02:00 committed by GitHub
parent 965bb2c8df
commit 75f27d6318
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 251 additions and 255 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

170
tests/components/mold_indicator/test_sensor.py
View File

@ -1,5 +1,5 @@
"""The tests for the MoldIndicator sensor.""" """The tests for the MoldIndicator sensor."""
import unittest import pytest
from homeassistant.components.mold_indicator.sensor import ( from homeassistant.components.mold_indicator.sensor import (
ATTR_CRITICAL_TEMP, ATTR_CRITICAL_TEMP,
@ -12,36 +12,27 @@ from homeassistant.const import (
STATE_UNKNOWN, STATE_UNKNOWN,
TEMP_CELSIUS, TEMP_CELSIUS,
) )
from homeassistant.setup import setup_component from homeassistant.setup import async_setup_component
from tests.common import get_test_home_assistant
class TestSensorMoldIndicator(unittest.TestCase): @pytest.fixture(autouse=True)
"""Test the MoldIndicator sensor.""" def init_sensors_fixture(hass):
def setUp(self):
"""Set up things to be run when tests are started.""" """Set up things to be run when tests are started."""
self.hass = get_test_home_assistant() hass.states.async_set(
self.hass.states.set(
"test.indoortemp", "20", {ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS} "test.indoortemp", "20", {ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS}
) )
self.hass.states.set( hass.states.async_set(
"test.outdoortemp", "10", {ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS} "test.outdoortemp", "10", {ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS}
) )
self.hass.states.set( hass.states.async_set(
"test.indoorhumidity", "50", {ATTR_UNIT_OF_MEASUREMENT: PERCENTAGE} "test.indoorhumidity", "50", {ATTR_UNIT_OF_MEASUREMENT: PERCENTAGE}
) )
self.addCleanup(self.tear_down_cleanup)
def tear_down_cleanup(self):
"""Stop down everything that was started."""
self.hass.stop()
def test_setup(self): async def test_setup(hass):
"""Test the mold indicator sensor setup.""" """Test the mold indicator sensor setup."""
assert setup_component( assert await async_setup_component(
self.hass, hass,
sensor.DOMAIN, sensor.DOMAIN,
{ {
"sensor": { "sensor": {
@ -53,25 +44,26 @@ class TestSensorMoldIndicator(unittest.TestCase):
} }
}, },
) )
self.hass.block_till_done() await hass.async_block_till_done()
moldind = self.hass.states.get("sensor.mold_indicator") moldind = hass.states.get("sensor.mold_indicator")
assert moldind assert moldind
assert PERCENTAGE == moldind.attributes.get("unit_of_measurement") assert PERCENTAGE == moldind.attributes.get("unit_of_measurement")
def test_invalidcalib(self):
async def test_invalidcalib(hass):
"""Test invalid sensor values.""" """Test invalid sensor values."""
self.hass.states.set( hass.states.async_set(
"test.indoortemp", "10", {ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS} "test.indoortemp", "10", {ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS}
) )
self.hass.states.set( hass.states.async_set(
"test.outdoortemp", "10", {ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS} "test.outdoortemp", "10", {ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS}
) )
self.hass.states.set( hass.states.async_set(
"test.indoorhumidity", "0", {ATTR_UNIT_OF_MEASUREMENT: PERCENTAGE} "test.indoorhumidity", "0", {ATTR_UNIT_OF_MEASUREMENT: PERCENTAGE}
) )
assert setup_component( assert await async_setup_component(
self.hass, hass,
sensor.DOMAIN, sensor.DOMAIN,
{ {
"sensor": { "sensor": {
@ -83,29 +75,30 @@ class TestSensorMoldIndicator(unittest.TestCase):
} }
}, },
) )
self.hass.block_till_done() await hass.async_block_till_done()
self.hass.start() await hass.async_start()
self.hass.block_till_done() await hass.async_block_till_done()
moldind = self.hass.states.get("sensor.mold_indicator") moldind = hass.states.get("sensor.mold_indicator")
assert moldind assert moldind
assert moldind.state == "unavailable" assert moldind.state == "unavailable"
assert moldind.attributes.get(ATTR_DEWPOINT) is None assert moldind.attributes.get(ATTR_DEWPOINT) is None
assert moldind.attributes.get(ATTR_CRITICAL_TEMP) is None assert moldind.attributes.get(ATTR_CRITICAL_TEMP) is None
def test_invalidhum(self):
async def test_invalidhum(hass):
"""Test invalid sensor values.""" """Test invalid sensor values."""
self.hass.states.set( hass.states.async_set(
"test.indoortemp", "10", {ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS} "test.indoortemp", "10", {ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS}
) )
self.hass.states.set( hass.states.async_set(
"test.outdoortemp", "10", {ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS} "test.outdoortemp", "10", {ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS}
) )
self.hass.states.set( hass.states.async_set(
"test.indoorhumidity", "-1", {ATTR_UNIT_OF_MEASUREMENT: PERCENTAGE} "test.indoorhumidity", "-1", {ATTR_UNIT_OF_MEASUREMENT: PERCENTAGE}
) )
assert setup_component( assert await async_setup_component(
self.hass, hass,
sensor.DOMAIN, sensor.DOMAIN,
{ {
"sensor": { "sensor": {
@ -118,39 +111,40 @@ class TestSensorMoldIndicator(unittest.TestCase):
}, },
) )
self.hass.block_till_done() await hass.async_block_till_done()
self.hass.start() await hass.async_start()
self.hass.block_till_done() await hass.async_block_till_done()
moldind = self.hass.states.get("sensor.mold_indicator") moldind = hass.states.get("sensor.mold_indicator")
assert moldind assert moldind
assert moldind.state == "unavailable" assert moldind.state == "unavailable"
assert moldind.attributes.get(ATTR_DEWPOINT) is None assert moldind.attributes.get(ATTR_DEWPOINT) is None
assert moldind.attributes.get(ATTR_CRITICAL_TEMP) is None assert moldind.attributes.get(ATTR_CRITICAL_TEMP) is None
self.hass.states.set( hass.states.async_set(
"test.indoorhumidity", "A", {ATTR_UNIT_OF_MEASUREMENT: PERCENTAGE} "test.indoorhumidity", "A", {ATTR_UNIT_OF_MEASUREMENT: PERCENTAGE}
) )
self.hass.block_till_done() await hass.async_block_till_done()
moldind = self.hass.states.get("sensor.mold_indicator") moldind = hass.states.get("sensor.mold_indicator")
assert moldind assert moldind
assert moldind.state == "unavailable" assert moldind.state == "unavailable"
assert moldind.attributes.get(ATTR_DEWPOINT) is None assert moldind.attributes.get(ATTR_DEWPOINT) is None
assert moldind.attributes.get(ATTR_CRITICAL_TEMP) is None assert moldind.attributes.get(ATTR_CRITICAL_TEMP) is None
self.hass.states.set( hass.states.async_set(
"test.indoorhumidity", "10", {ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS} "test.indoorhumidity", "10", {ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS}
) )
self.hass.block_till_done() await hass.async_block_till_done()
moldind = self.hass.states.get("sensor.mold_indicator") moldind = hass.states.get("sensor.mold_indicator")
assert moldind assert moldind
assert moldind.state == "unavailable" assert moldind.state == "unavailable"
assert moldind.attributes.get(ATTR_DEWPOINT) is None assert moldind.attributes.get(ATTR_DEWPOINT) is None
assert moldind.attributes.get(ATTR_CRITICAL_TEMP) is None assert moldind.attributes.get(ATTR_CRITICAL_TEMP) is None
def test_calculation(self):
async def test_calculation(hass):
"""Test the mold indicator internal calculations.""" """Test the mold indicator internal calculations."""
assert setup_component( assert await async_setup_component(
self.hass, hass,
sensor.DOMAIN, sensor.DOMAIN,
{ {
"sensor": { "sensor": {
@ -162,10 +156,10 @@ class TestSensorMoldIndicator(unittest.TestCase):
} }
}, },
) )
self.hass.block_till_done() await hass.async_block_till_done()
self.hass.start() await hass.async_start()
self.hass.block_till_done() await hass.async_block_till_done()
moldind = self.hass.states.get("sensor.mold_indicator") moldind = hass.states.get("sensor.mold_indicator")
assert moldind assert moldind
# assert dewpoint # assert dewpoint
@ -185,10 +179,11 @@ class TestSensorMoldIndicator(unittest.TestCase):
assert state assert state
assert state == "68" assert state == "68"
def test_unknown_sensor(self):
async def test_unknown_sensor(hass):
"""Test the sensor_changed function.""" """Test the sensor_changed function."""
assert setup_component( assert await async_setup_component(
self.hass, hass,
sensor.DOMAIN, sensor.DOMAIN,
{ {
"sensor": { "sensor": {
@ -200,52 +195,52 @@ class TestSensorMoldIndicator(unittest.TestCase):
} }
}, },
) )
self.hass.block_till_done() await hass.async_block_till_done()
self.hass.start() await hass.async_start()
self.hass.states.set( hass.states.async_set(
"test.indoortemp", STATE_UNKNOWN, {ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS} "test.indoortemp", STATE_UNKNOWN, {ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS}
) )
self.hass.block_till_done() await hass.async_block_till_done()
moldind = self.hass.states.get("sensor.mold_indicator") moldind = hass.states.get("sensor.mold_indicator")
assert moldind assert moldind
assert moldind.state == "unavailable" assert moldind.state == "unavailable"
assert moldind.attributes.get(ATTR_DEWPOINT) is None assert moldind.attributes.get(ATTR_DEWPOINT) is None
assert moldind.attributes.get(ATTR_CRITICAL_TEMP) is None assert moldind.attributes.get(ATTR_CRITICAL_TEMP) is None
self.hass.states.set( hass.states.async_set(
"test.indoortemp", "30", {ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS} "test.indoortemp", "30", {ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS}
) )
self.hass.states.set( hass.states.async_set(
"test.outdoortemp", STATE_UNKNOWN, {ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS} "test.outdoortemp", STATE_UNKNOWN, {ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS}
) )
self.hass.block_till_done() await hass.async_block_till_done()
moldind = self.hass.states.get("sensor.mold_indicator") moldind = hass.states.get("sensor.mold_indicator")
assert moldind assert moldind
assert moldind.state == "unavailable" assert moldind.state == "unavailable"
assert moldind.attributes.get(ATTR_DEWPOINT) is None assert moldind.attributes.get(ATTR_DEWPOINT) is None
assert moldind.attributes.get(ATTR_CRITICAL_TEMP) is None assert moldind.attributes.get(ATTR_CRITICAL_TEMP) is None
self.hass.states.set( hass.states.async_set(
"test.outdoortemp", "25", {ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS} "test.outdoortemp", "25", {ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS}
) )
self.hass.states.set( hass.states.async_set(
"test.indoorhumidity", "test.indoorhumidity",
STATE_UNKNOWN, STATE_UNKNOWN,
{ATTR_UNIT_OF_MEASUREMENT: PERCENTAGE}, {ATTR_UNIT_OF_MEASUREMENT: PERCENTAGE},
) )
self.hass.block_till_done() await hass.async_block_till_done()
moldind = self.hass.states.get("sensor.mold_indicator") moldind = hass.states.get("sensor.mold_indicator")
assert moldind assert moldind
assert moldind.state == "unavailable" assert moldind.state == "unavailable"
assert moldind.attributes.get(ATTR_DEWPOINT) is None assert moldind.attributes.get(ATTR_DEWPOINT) is None
assert moldind.attributes.get(ATTR_CRITICAL_TEMP) is None assert moldind.attributes.get(ATTR_CRITICAL_TEMP) is None
self.hass.states.set( hass.states.async_set(
"test.indoorhumidity", "20", {ATTR_UNIT_OF_MEASUREMENT: PERCENTAGE} "test.indoorhumidity", "20", {ATTR_UNIT_OF_MEASUREMENT: PERCENTAGE}
) )
self.hass.block_till_done() await hass.async_block_till_done()
moldind = self.hass.states.get("sensor.mold_indicator") moldind = hass.states.get("sensor.mold_indicator")
assert moldind assert moldind
assert moldind.state == "23" assert moldind.state == "23"
@ -258,10 +253,11 @@ class TestSensorMoldIndicator(unittest.TestCase):
assert esttemp assert esttemp
assert esttemp == 27.5 assert esttemp == 27.5
def test_sensor_changed(self):
async def test_sensor_changed(hass):
"""Test the sensor_changed function.""" """Test the sensor_changed function."""
assert setup_component( assert await async_setup_component(
self.hass, hass,
sensor.DOMAIN, sensor.DOMAIN,
{ {
"sensor": { "sensor": {
@ -273,23 +269,23 @@ class TestSensorMoldIndicator(unittest.TestCase):
} }
}, },
) )
self.hass.block_till_done() await hass.async_block_till_done()
self.hass.start() await hass.async_start()
self.hass.states.set( hass.states.async_set(
"test.indoortemp", "30", {ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS} "test.indoortemp", "30", {ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS}
) )
self.hass.block_till_done() await hass.async_block_till_done()
assert self.hass.states.get("sensor.mold_indicator").state == "90" assert hass.states.get("sensor.mold_indicator").state == "90"
self.hass.states.set( hass.states.async_set(
"test.outdoortemp", "25", {ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS} "test.outdoortemp", "25", {ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS}
) )
self.hass.block_till_done() await hass.async_block_till_done()
assert self.hass.states.get("sensor.mold_indicator").state == "57" assert hass.states.get("sensor.mold_indicator").state == "57"
self.hass.states.set( hass.states.async_set(
"test.indoorhumidity", "20", {ATTR_UNIT_OF_MEASUREMENT: PERCENTAGE} "test.indoorhumidity", "20", {ATTR_UNIT_OF_MEASUREMENT: PERCENTAGE}
) )
self.hass.block_till_done() await hass.async_block_till_done()
assert self.hass.states.get("sensor.mold_indicator").state == "23" assert hass.states.get("sensor.mold_indicator").state == "23"