Skip to content

Async tests for counter #18684

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
emlove merged 1 commit into from
Nov 24, 2018
Merged

Async tests for counter #18684

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
18 changes: 0 additions & 18 deletions tests/components/counter/common.py
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -10,12 +10,6 @@
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
@bind_hass
def async_increment(hass, entity_id):
Expand All @@ -24,12 +18,6 @@ def async_increment(hass, 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
@bind_hass
def async_decrement(hass, entity_id):
Expand All @@ -38,12 +26,6 @@ def async_decrement(hass, 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
@bind_hass
def async_reset(hass, entity_id):
Expand Down
214 changes: 102 additions & 112 deletions tests/components/counter/test_init.py
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,163 +1,153 @@
"""The tests for the counter component."""
# pylint: disable=protected-access
import asyncio
import unittest
import logging

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 (
DOMAIN, CONF_INITIAL, CONF_RESTORE, CONF_STEP, CONF_NAME, CONF_ICON)
from homeassistant.const import (ATTR_ICON, ATTR_FRIENDLY_NAME)

from tests.common import (get_test_home_assistant, mock_restore_cache)
from tests.components.counter.common import decrement, increment, reset
from tests.common import mock_restore_cache
from tests.components.counter.common import (
async_decrement, async_increment, async_reset)

_LOGGER = logging.getLogger(__name__)


class TestCounter(unittest.TestCase):
"""Test the counter component."""

# pylint: disable=invalid-name
def setUp(self):
"""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):
"""Test config."""
invalid_configs = [
None,
1,
{},
{'name with space': None},
]

for cfg in invalid_configs:
assert not setup_component(self.hass, DOMAIN, {DOMAIN: cfg})

def test_config_options(self):
"""Test configuration options."""
count_start = len(self.hass.states.entity_ids())

_LOGGER.debug('ENTITIES @ start: %s', self.hass.states.entity_ids())

config = {
DOMAIN: {
'test_1': {},
'test_2': {
CONF_NAME: 'Hello World',
CONF_ICON: 'mdi:work',
CONF_INITIAL: 10,
CONF_RESTORE: False,
CONF_STEP: 5,
}
async def test_config(hass):
"""Test config."""
invalid_configs = [
None,
1,
{},
{'name with space': None},
]

for cfg in invalid_configs:
assert not await async_setup_component(hass, DOMAIN, {DOMAIN: cfg})


async def test_config_options(hass):
"""Test configuration options."""
count_start = len(hass.states.async_entity_ids())

_LOGGER.debug('ENTITIES @ start: %s', hass.states.async_entity_ids())

config = {
DOMAIN: {
'test_1': {},
'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)
self.hass.block_till_done()
assert await async_setup_component(hass, 'counter', config)
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())
self.hass.block_till_done()
assert count_start + 2 == len(hass.states.async_entity_ids())
await hass.async_block_till_done()

state_1 = self.hass.states.get('counter.test_1')
state_2 = self.hass.states.get('counter.test_2')
state_1 = hass.states.get('counter.test_1')
state_2 = hass.states.get('counter.test_2')

assert state_1 is not None
assert state_2 is not None
assert state_1 is not None
assert state_2 is not None

assert 0 == int(state_1.state)
assert ATTR_ICON not in state_1.attributes
assert ATTR_FRIENDLY_NAME not in state_1.attributes
assert 0 == int(state_1.state)
assert ATTR_ICON not in state_1.attributes
assert ATTR_FRIENDLY_NAME not in state_1.attributes

assert 10 == int(state_2.state)
assert 'Hello World' == \
state_2.attributes.get(ATTR_FRIENDLY_NAME)
assert 'mdi:work' == state_2.attributes.get(ATTR_ICON)
assert 10 == int(state_2.state)
assert 'Hello World' == \
state_2.attributes.get(ATTR_FRIENDLY_NAME)
assert 'mdi:work' == state_2.attributes.get(ATTR_ICON)

def test_methods(self):
"""Test increment, decrement, and reset methods."""
config = {
DOMAIN: {
'test_1': {},
}

async def test_methods(hass):
"""Test increment, decrement, and reset methods."""
config = {
DOMAIN: {
'test_1': {},
}
}

assert setup_component(self.hass, 'counter', config)
assert await async_setup_component(hass, 'counter', config)

entity_id = 'counter.test_1'
entity_id = 'counter.test_1'

state = self.hass.states.get(entity_id)
assert 0 == int(state.state)
state = hass.states.get(entity_id)
assert 0 == int(state.state)

increment(self.hass, entity_id)
self.hass.block_till_done()
async_increment(hass, entity_id)
await hass.async_block_till_done()

state = self.hass.states.get(entity_id)
assert 1 == int(state.state)
state = hass.states.get(entity_id)
assert 1 == int(state.state)

increment(self.hass, entity_id)
self.hass.block_till_done()
async_increment(hass, entity_id)
await hass.async_block_till_done()

state = self.hass.states.get(entity_id)
assert 2 == int(state.state)
state = hass.states.get(entity_id)
assert 2 == int(state.state)

decrement(self.hass, entity_id)
self.hass.block_till_done()
async_decrement(hass, entity_id)
await hass.async_block_till_done()

state = self.hass.states.get(entity_id)
assert 1 == int(state.state)
state = hass.states.get(entity_id)
assert 1 == int(state.state)

reset(self.hass, entity_id)
self.hass.block_till_done()
async_reset(hass, entity_id)
await hass.async_block_till_done()

state = self.hass.states.get(entity_id)
assert 0 == int(state.state)
state = 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,
}

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'
entity_id = 'counter.test'

state = self.hass.states.get(entity_id)
assert 10 == int(state.state)
state = hass.states.get(entity_id)
assert 10 == int(state.state)

increment(self.hass, entity_id)
self.hass.block_till_done()
async_increment(hass, entity_id)
await hass.async_block_till_done()

state = self.hass.states.get(entity_id)
assert 15 == int(state.state)
state = hass.states.get(entity_id)
assert 15 == int(state.state)

increment(self.hass, entity_id)
self.hass.block_till_done()
async_increment(hass, entity_id)
await hass.async_block_till_done()

state = self.hass.states.get(entity_id)
assert 20 == int(state.state)
state = hass.states.get(entity_id)
assert 20 == int(state.state)

decrement(self.hass, entity_id)
self.hass.block_till_done()
async_decrement(hass, entity_id)
await hass.async_block_till_done()

state = self.hass.states.get(entity_id)
assert 15 == int(state.state)
state = hass.states.get(entity_id)
assert 15 == int(state.state)


@asyncio.coroutine
Expand Down