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

Async tests for counter (#18684)

Browse source
This commit is contained in:
Adam Mills 2018-11-24 16:12:29 -05:00 • committed by GitHub
parent 66f1643de5
commit 6f0a3b4b22
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
2 changed files with 110 additions and 138 deletions
Download patch file Download diff file Expand all files Collapse all files

18
tests/components/counter/common.py
View file

@ -10,12 +10,6 @@ from homeassistant.core import callback
from homeassistant.loader import bind_hass from homeassistant.loader import bind_hass
@bind_hass
def increment(hass, entity_id):
"""Increment a counter."""
hass.add_job(async_increment, hass, entity_id)
@callback @callback
@bind_hass @bind_hass
def async_increment(hass, entity_id): def async_increment(hass, entity_id):
@ -24,12 +18,6 @@ def async_increment(hass, entity_id):
DOMAIN, SERVICE_INCREMENT, {ATTR_ENTITY_ID: entity_id})) DOMAIN, SERVICE_INCREMENT, {ATTR_ENTITY_ID: entity_id}))
@bind_hass
def decrement(hass, entity_id):
"""Decrement a counter."""
hass.add_job(async_decrement, hass, entity_id)
@callback @callback
@bind_hass @bind_hass
def async_decrement(hass, entity_id): def async_decrement(hass, entity_id):
@ -38,12 +26,6 @@ def async_decrement(hass, entity_id):
DOMAIN, SERVICE_DECREMENT, {ATTR_ENTITY_ID: entity_id})) DOMAIN, SERVICE_DECREMENT, {ATTR_ENTITY_ID: entity_id}))
@bind_hass
def reset(hass, entity_id):
"""Reset a counter."""
hass.add_job(async_reset, hass, entity_id)
@callback @callback
@bind_hass @bind_hass
def async_reset(hass, entity_id): def async_reset(hass, entity_id):

230
tests/components/counter/test_init.py
View file

@ -1,163 +1,153 @@
"""The tests for the counter component.""" """The tests for the counter component."""
# pylint: disable=protected-access # pylint: disable=protected-access
import asyncio import asyncio
import unittest
import logging import logging
from homeassistant.core import CoreState, State, Context from homeassistant.core import CoreState, State, Context
from homeassistant.setup import setup_component, async_setup_component from homeassistant.setup import async_setup_component
from homeassistant.components.counter import ( from homeassistant.components.counter import (
DOMAIN, CONF_INITIAL, CONF_RESTORE, CONF_STEP, CONF_NAME, CONF_ICON) DOMAIN, CONF_INITIAL, CONF_RESTORE, CONF_STEP, CONF_NAME, CONF_ICON)
from homeassistant.const import (ATTR_ICON, ATTR_FRIENDLY_NAME) from homeassistant.const import (ATTR_ICON, ATTR_FRIENDLY_NAME)
from tests.common import (get_test_home_assistant, mock_restore_cache) from tests.common import mock_restore_cache
from tests.components.counter.common import decrement, increment, reset from tests.components.counter.common import (
async_decrement, async_increment, async_reset)
_LOGGER = logging.getLogger(__name__) _LOGGER = logging.getLogger(__name__)
class TestCounter(unittest.TestCase): async def test_config(hass):
"""Test the counter component.""" """Test config."""
invalid_configs = [
None,
1,
{},
{'name with space': None},
]
# pylint: disable=invalid-name for cfg in invalid_configs:
def setUp(self): assert not await async_setup_component(hass, DOMAIN, {DOMAIN: cfg})
"""Set up things to be run when tests are started."""
self.hass = get_test_home_assistant()
# pylint: disable=invalid-name
def tearDown(self):
"""Stop everything that was started."""
self.hass.stop()
def test_config(self): async def test_config_options(hass):
"""Test config.""" """Test configuration options."""
invalid_configs = [ count_start = len(hass.states.async_entity_ids())
None,
1,
{},
{'name with space': None},
]
for cfg in invalid_configs: _LOGGER.debug('ENTITIES @ start: %s', hass.states.async_entity_ids())
assert not setup_component(self.hass, DOMAIN, {DOMAIN: cfg})
def test_config_options(self): config = {
"""Test configuration options.""" DOMAIN: {
count_start = len(self.hass.states.entity_ids()) 'test_1': {},
'test_2': {
_LOGGER.debug('ENTITIES @ start: %s', self.hass.states.entity_ids()) CONF_NAME: 'Hello World',
CONF_ICON: 'mdi:work',
config = { CONF_INITIAL: 10,
DOMAIN: { CONF_RESTORE: False,
'test_1': {}, CONF_STEP: 5,
'test_2': {
CONF_NAME: 'Hello World',
CONF_ICON: 'mdi:work',
CONF_INITIAL: 10,
CONF_RESTORE: False,
CONF_STEP: 5,
}
} }
} }
}
assert setup_component(self.hass, 'counter', config) assert await async_setup_component(hass, 'counter', config)
self.hass.block_till_done() await hass.async_block_till_done()
_LOGGER.debug('ENTITIES: %s', self.hass.states.entity_ids()) _LOGGER.debug('ENTITIES: %s', hass.states.async_entity_ids())
assert count_start + 2 == len(self.hass.states.entity_ids()) assert count_start + 2 == len(hass.states.async_entity_ids())
self.hass.block_till_done() await hass.async_block_till_done()
state_1 = self.hass.states.get('counter.test_1') state_1 = hass.states.get('counter.test_1')
state_2 = self.hass.states.get('counter.test_2') state_2 = hass.states.get('counter.test_2')
assert state_1 is not None assert state_1 is not None
assert state_2 is not None assert state_2 is not None
assert 0 == int(state_1.state) assert 0 == int(state_1.state)
assert ATTR_ICON not in state_1.attributes assert ATTR_ICON not in state_1.attributes
assert ATTR_FRIENDLY_NAME not in state_1.attributes assert ATTR_FRIENDLY_NAME not in state_1.attributes
assert 10 == int(state_2.state) assert 10 == int(state_2.state)
assert 'Hello World' == \ assert 'Hello World' == \
state_2.attributes.get(ATTR_FRIENDLY_NAME) state_2.attributes.get(ATTR_FRIENDLY_NAME)
assert 'mdi:work' == state_2.attributes.get(ATTR_ICON) assert 'mdi:work' == state_2.attributes.get(ATTR_ICON)
def test_methods(self):
"""Test increment, decrement, and reset methods.""" async def test_methods(hass):
config = { """Test increment, decrement, and reset methods."""
DOMAIN: { config = {
'test_1': {}, DOMAIN: {
'test_1': {},
}
}
assert await async_setup_component(hass, 'counter', config)
entity_id = 'counter.test_1'
state = hass.states.get(entity_id)
assert 0 == int(state.state)
async_increment(hass, entity_id)
await hass.async_block_till_done()
state = hass.states.get(entity_id)
assert 1 == int(state.state)
async_increment(hass, entity_id)
await hass.async_block_till_done()
state = hass.states.get(entity_id)
assert 2 == int(state.state)
async_decrement(hass, entity_id)
await hass.async_block_till_done()
state = hass.states.get(entity_id)
assert 1 == int(state.state)
async_reset(hass, entity_id)
await hass.async_block_till_done()
state = hass.states.get(entity_id)
assert 0 == int(state.state)
async def test_methods_with_config(hass):
"""Test increment, decrement, and reset methods with configuration."""
config = {
DOMAIN: {
'test': {
CONF_NAME: 'Hello World',
CONF_INITIAL: 10,
CONF_STEP: 5,
} }
} }
}
assert setup_component(self.hass, 'counter', config) assert await async_setup_component(hass, 'counter', config)
entity_id = 'counter.test_1' entity_id = 'counter.test'
state = self.hass.states.get(entity_id) state = hass.states.get(entity_id)
assert 0 == int(state.state) assert 10 == int(state.state)
increment(self.hass, entity_id) async_increment(hass, entity_id)
self.hass.block_till_done() await hass.async_block_till_done()
state = self.hass.states.get(entity_id) state = hass.states.get(entity_id)
assert 1 == int(state.state) assert 15 == int(state.state)
increment(self.hass, entity_id) async_increment(hass, entity_id)
self.hass.block_till_done() await hass.async_block_till_done()
state = self.hass.states.get(entity_id) state = hass.states.get(entity_id)
assert 2 == int(state.state) assert 20 == int(state.state)
decrement(self.hass, entity_id) async_decrement(hass, entity_id)
self.hass.block_till_done() await hass.async_block_till_done()
state = self.hass.states.get(entity_id) state = hass.states.get(entity_id)
assert 1 == int(state.state) assert 15 == int(state.state)
reset(self.hass, entity_id)
self.hass.block_till_done()
state = self.hass.states.get(entity_id)
assert 0 == int(state.state)
def test_methods_with_config(self):
"""Test increment, decrement, and reset methods with configuration."""
config = {
DOMAIN: {
'test': {
CONF_NAME: 'Hello World',
CONF_INITIAL: 10,
CONF_STEP: 5,
}
}
}
assert setup_component(self.hass, 'counter', config)
entity_id = 'counter.test'
state = self.hass.states.get(entity_id)
assert 10 == int(state.state)
increment(self.hass, entity_id)
self.hass.block_till_done()
state = self.hass.states.get(entity_id)
assert 15 == int(state.state)
increment(self.hass, entity_id)
self.hass.block_till_done()
state = self.hass.states.get(entity_id)
assert 20 == int(state.state)
decrement(self.hass, entity_id)
self.hass.block_till_done()
state = self.hass.states.get(entity_id)
assert 15 == int(state.state)
@asyncio.coroutine @asyncio.coroutine