diff --git a/tests/components/counter/common.py b/tests/components/counter/common.py
index 36d09979d0d..2fad06027fc 100644
--- a/tests/components/counter/common.py
+++ b/tests/components/counter/common.py
@@ -10,12 +10,6 @@ from homeassistant.core import callback
 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):
@@ -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):
@@ -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):
diff --git a/tests/components/counter/test_init.py b/tests/components/counter/test_init.py
index c8411bf2fde..97a39cdeb73 100644
--- a/tests/components/counter/test_init.py
+++ b/tests/components/counter/test_init.py
@@ -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."""
+async def test_config(hass):
+    """Test config."""
+    invalid_configs = [
+        None,
+        1,
+        {},
+        {'name with space': None},
+    ]
 
-    # pylint: disable=invalid-name
-    def setUp(self):
-        """Set up things to be run when tests are started."""
-        self.hass = get_test_home_assistant()
+    for cfg in invalid_configs:
+        assert not await async_setup_component(hass, DOMAIN, {DOMAIN: cfg})
 
-    # 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},
-        ]
+async def test_config_options(hass):
+    """Test configuration options."""
+    count_start = len(hass.states.async_entity_ids())
 
-        for cfg in invalid_configs:
-            assert not setup_component(self.hass, DOMAIN, {DOMAIN: cfg})
+    _LOGGER.debug('ENTITIES @ start: %s', hass.states.async_entity_ids())
 
-    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,
-                }
+    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 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)
-        assert 0 == 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 1 == 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 2 == 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 1 == 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)
+    state = hass.states.get(entity_id)
+    assert 15 == int(state.state)
 
 
 @asyncio.coroutine