Async tests for device tracker mqtt (#18680)

tests/components/device_tracker/test_mqtt.py

@@ -1,147 +1,144 @@
 """The tests for the MQTT device tracker platform."""
-import asyncio
-import unittest
-from unittest.mock import patch
 import logging
 import os
+from asynctest import patch
+import pytest
 
-from homeassistant.setup import setup_component
+from homeassistant.setup import async_setup_component
 from homeassistant.components import device_tracker
 from homeassistant.const import CONF_PLATFORM
 
 from tests.common import (
-    get_test_home_assistant, mock_mqtt_component, fire_mqtt_message)
+    async_mock_mqtt_component, async_fire_mqtt_message)
 
 _LOGGER = logging.getLogger(__name__)
 
 
-class TestComponentsDeviceTrackerMQTT(unittest.TestCase):
+@pytest.fixture(autouse=True)
-    """Test MQTT device tracker platform."""
+def setup_comp(hass):
+    """Initialize components."""
+    hass.loop.run_until_complete(async_mock_mqtt_component(hass))
+    yaml_devices = hass.config.path(device_tracker.YAML_DEVICES)
+    yield
+    if os.path.isfile(yaml_devices):
+        os.remove(yaml_devices)
 
-    def setUp(self):  # pylint: disable=invalid-name
-        """Set up things to be run when tests are started."""
-        self.hass = get_test_home_assistant()
-        mock_mqtt_component(self.hass)
 
-    def tearDown(self):  # pylint: disable=invalid-name
+async def test_ensure_device_tracker_platform_validation(hass):
-        """Stop everything that was started."""
+    """Test if platform validation was done."""
-        self.hass.stop()
+    async def mock_setup_scanner(hass, config, see, discovery_info=None):
-        try:
+        """Check that Qos was added by validation."""
-            os.remove(self.hass.config.path(device_tracker.YAML_DEVICES))
+        assert 'qos' in config
-        except FileNotFoundError:
-            pass
 
-    def test_ensure_device_tracker_platform_validation(self):
+    with patch('homeassistant.components.device_tracker.mqtt.'
-        """Test if platform validation was done."""
+               'async_setup_scanner', autospec=True,
-        @asyncio.coroutine
+               side_effect=mock_setup_scanner) as mock_sp:
-        def mock_setup_scanner(hass, config, see, discovery_info=None):
-            """Check that Qos was added by validation."""
-            assert 'qos' in config
 
-        with patch('homeassistant.components.device_tracker.mqtt.'
-                   'async_setup_scanner', autospec=True,
-                   side_effect=mock_setup_scanner) as mock_sp:
-
-            dev_id = 'paulus'
-            topic = '/location/paulus'
-            assert setup_component(self.hass, device_tracker.DOMAIN, {
-                device_tracker.DOMAIN: {
-                    CONF_PLATFORM: 'mqtt',
-                    'devices': {dev_id: topic}
-                }
-            })
-            assert mock_sp.call_count == 1
-
-    def test_new_message(self):
-        """Test new message."""
         dev_id = 'paulus'
-        entity_id = device_tracker.ENTITY_ID_FORMAT.format(dev_id)
         topic = '/location/paulus'
-        location = 'work'
+        assert await async_setup_component(hass, device_tracker.DOMAIN, {
-
-        self.hass.config.components = set(['mqtt', 'zone'])
-        assert setup_component(self.hass, device_tracker.DOMAIN, {
             device_tracker.DOMAIN: {
                 CONF_PLATFORM: 'mqtt',
                 'devices': {dev_id: topic}
             }
         })
-        fire_mqtt_message(self.hass, topic, location)
+        assert mock_sp.call_count == 1
-        self.hass.block_till_done()
-        assert location == self.hass.states.get(entity_id).state
 
-    def test_single_level_wildcard_topic(self):
-        """Test single level wildcard topic."""
-        dev_id = 'paulus'
-        entity_id = device_tracker.ENTITY_ID_FORMAT.format(dev_id)
-        subscription = '/location/+/paulus'
-        topic = '/location/room/paulus'
-        location = 'work'
 
-        self.hass.config.components = set(['mqtt', 'zone'])
+async def test_new_message(hass):
-        assert setup_component(self.hass, device_tracker.DOMAIN, {
+    """Test new message."""
-            device_tracker.DOMAIN: {
+    dev_id = 'paulus'
-                CONF_PLATFORM: 'mqtt',
+    entity_id = device_tracker.ENTITY_ID_FORMAT.format(dev_id)
-                'devices': {dev_id: subscription}
+    topic = '/location/paulus'
-            }
+    location = 'work'
-        })
-        fire_mqtt_message(self.hass, topic, location)
-        self.hass.block_till_done()
-        assert location == self.hass.states.get(entity_id).state
 
-    def test_multi_level_wildcard_topic(self):
+    hass.config.components = set(['mqtt', 'zone'])
-        """Test multi level wildcard topic."""
+    assert await async_setup_component(hass, device_tracker.DOMAIN, {
-        dev_id = 'paulus'
+        device_tracker.DOMAIN: {
-        entity_id = device_tracker.ENTITY_ID_FORMAT.format(dev_id)
+            CONF_PLATFORM: 'mqtt',
-        subscription = '/location/#'
+            'devices': {dev_id: topic}
-        topic = '/location/room/paulus'
+        }
-        location = 'work'
+    })
+    async_fire_mqtt_message(hass, topic, location)
+    await hass.async_block_till_done()
+    assert location == hass.states.get(entity_id).state
 
-        self.hass.config.components = set(['mqtt', 'zone'])
-        assert setup_component(self.hass, device_tracker.DOMAIN, {
-            device_tracker.DOMAIN: {
-                CONF_PLATFORM: 'mqtt',
-                'devices': {dev_id: subscription}
-            }
-        })
-        fire_mqtt_message(self.hass, topic, location)
-        self.hass.block_till_done()
-        assert location == self.hass.states.get(entity_id).state
 
-    def test_single_level_wildcard_topic_not_matching(self):
+async def test_single_level_wildcard_topic(hass):
-        """Test not matching single level wildcard topic."""
+    """Test single level wildcard topic."""
-        dev_id = 'paulus'
+    dev_id = 'paulus'
-        entity_id = device_tracker.ENTITY_ID_FORMAT.format(dev_id)
+    entity_id = device_tracker.ENTITY_ID_FORMAT.format(dev_id)
-        subscription = '/location/+/paulus'
+    subscription = '/location/+/paulus'
-        topic = '/location/paulus'
+    topic = '/location/room/paulus'
-        location = 'work'
+    location = 'work'
 
-        self.hass.config.components = set(['mqtt', 'zone'])
+    hass.config.components = set(['mqtt', 'zone'])
-        assert setup_component(self.hass, device_tracker.DOMAIN, {
+    assert await async_setup_component(hass, device_tracker.DOMAIN, {
-            device_tracker.DOMAIN: {
+        device_tracker.DOMAIN: {
-                CONF_PLATFORM: 'mqtt',
+            CONF_PLATFORM: 'mqtt',
-                'devices': {dev_id: subscription}
+            'devices': {dev_id: subscription}
-            }
+        }
-        })
+    })
-        fire_mqtt_message(self.hass, topic, location)
+    async_fire_mqtt_message(hass, topic, location)
-        self.hass.block_till_done()
+    await hass.async_block_till_done()
-        assert self.hass.states.get(entity_id) is None
+    assert location == hass.states.get(entity_id).state
 
-    def test_multi_level_wildcard_topic_not_matching(self):
-        """Test not matching multi level wildcard topic."""
-        dev_id = 'paulus'
-        entity_id = device_tracker.ENTITY_ID_FORMAT.format(dev_id)
-        subscription = '/location/#'
-        topic = '/somewhere/room/paulus'
-        location = 'work'
 
-        self.hass.config.components = set(['mqtt', 'zone'])
+async def test_multi_level_wildcard_topic(hass):
-        assert setup_component(self.hass, device_tracker.DOMAIN, {
+    """Test multi level wildcard topic."""
-            device_tracker.DOMAIN: {
+    dev_id = 'paulus'
-                CONF_PLATFORM: 'mqtt',
+    entity_id = device_tracker.ENTITY_ID_FORMAT.format(dev_id)
-                'devices': {dev_id: subscription}
+    subscription = '/location/#'
-            }
+    topic = '/location/room/paulus'
-        })
+    location = 'work'
-        fire_mqtt_message(self.hass, topic, location)
+
-        self.hass.block_till_done()
+    hass.config.components = set(['mqtt', 'zone'])
-        assert self.hass.states.get(entity_id) is None
+    assert await async_setup_component(hass, device_tracker.DOMAIN, {
+        device_tracker.DOMAIN: {
+            CONF_PLATFORM: 'mqtt',
+            'devices': {dev_id: subscription}
+        }
+    })
+    async_fire_mqtt_message(hass, topic, location)
+    await hass.async_block_till_done()
+    assert location == hass.states.get(entity_id).state
+
+
+async def test_single_level_wildcard_topic_not_matching(hass):
+    """Test not matching single level wildcard topic."""
+    dev_id = 'paulus'
+    entity_id = device_tracker.ENTITY_ID_FORMAT.format(dev_id)
+    subscription = '/location/+/paulus'
+    topic = '/location/paulus'
+    location = 'work'
+
+    hass.config.components = set(['mqtt', 'zone'])
+    assert await async_setup_component(hass, device_tracker.DOMAIN, {
+        device_tracker.DOMAIN: {
+            CONF_PLATFORM: 'mqtt',
+            'devices': {dev_id: subscription}
+        }
+    })
+    async_fire_mqtt_message(hass, topic, location)
+    await hass.async_block_till_done()
+    assert hass.states.get(entity_id) is None
+
+
+async def test_multi_level_wildcard_topic_not_matching(hass):
+    """Test not matching multi level wildcard topic."""
+    dev_id = 'paulus'
+    entity_id = device_tracker.ENTITY_ID_FORMAT.format(dev_id)
+    subscription = '/location/#'
+    topic = '/somewhere/room/paulus'
+    location = 'work'
+
+    hass.config.components = set(['mqtt', 'zone'])
+    assert await async_setup_component(hass, device_tracker.DOMAIN, {
+        device_tracker.DOMAIN: {
+            CONF_PLATFORM: 'mqtt',
+            'devices': {dev_id: subscription}
+        }
+    })
+    async_fire_mqtt_message(hass, topic, location)
+    await hass.async_block_till_done()
+    assert hass.states.get(entity_id) is None

tests/components/device_tracker/test_mqtt_json.py

@@ -1,17 +1,15 @@
 """The tests for the JSON MQTT device tracker platform."""
-import asyncio
 import json
-import unittest
+from asynctest import patch
-from unittest.mock import patch
 import logging
 import os
+import pytest
 
-from homeassistant.setup import setup_component
+from homeassistant.setup import async_setup_component
 from homeassistant.components import device_tracker
 from homeassistant.const import CONF_PLATFORM
 
-from tests.common import (
+from tests.common import async_mock_mqtt_component, async_fire_mqtt_message
-    get_test_home_assistant, mock_mqtt_component, fire_mqtt_message)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -25,172 +23,172 @@ LOCATION_MESSAGE_INCOMPLETE = {
     'longitude': 2.0}
 
 
-class TestComponentsDeviceTrackerJSONMQTT(unittest.TestCase):
+@pytest.fixture(autouse=True)
-    """Test JSON MQTT device tracker platform."""
+def setup_comp(hass):
+    """Initialize components."""
+    hass.loop.run_until_complete(async_mock_mqtt_component(hass))
+    yaml_devices = hass.config.path(device_tracker.YAML_DEVICES)
+    yield
+    if os.path.isfile(yaml_devices):
+        os.remove(yaml_devices)
 
-    def setUp(self):  # pylint: disable=invalid-name
-        """Set up things to be run when tests are started."""
-        self.hass = get_test_home_assistant()
-        mock_mqtt_component(self.hass)
 
-    def tearDown(self):  # pylint: disable=invalid-name
+async def test_ensure_device_tracker_platform_validation(hass):
-        """Stop everything that was started."""
+    """Test if platform validation was done."""
-        self.hass.stop()
+    async def mock_setup_scanner(hass, config, see, discovery_info=None):
-        try:
+        """Check that Qos was added by validation."""
-            os.remove(self.hass.config.path(device_tracker.YAML_DEVICES))
+        assert 'qos' in config
-        except FileNotFoundError:
-            pass
 
-    def test_ensure_device_tracker_platform_validation(self):
+    with patch('homeassistant.components.device_tracker.mqtt_json.'
-        """Test if platform validation was done."""
+               'async_setup_scanner', autospec=True,
-        @asyncio.coroutine
+               side_effect=mock_setup_scanner) as mock_sp:
-        def mock_setup_scanner(hass, config, see, discovery_info=None):
-            """Check that Qos was added by validation."""
-            assert 'qos' in config
 
-        with patch('homeassistant.components.device_tracker.mqtt_json.'
+        dev_id = 'paulus'
-                   'async_setup_scanner', autospec=True,
+        topic = 'location/paulus'
-                   side_effect=mock_setup_scanner) as mock_sp:
+        assert await async_setup_component(hass, device_tracker.DOMAIN, {
-
-            dev_id = 'paulus'
-            topic = 'location/paulus'
-            assert setup_component(self.hass, device_tracker.DOMAIN, {
-                device_tracker.DOMAIN: {
-                    CONF_PLATFORM: 'mqtt_json',
-                    'devices': {dev_id: topic}
-                }
-            })
-            assert mock_sp.call_count == 1
-
-    def test_json_message(self):
-        """Test json location message."""
-        dev_id = 'zanzito'
-        topic = 'location/zanzito'
-        location = json.dumps(LOCATION_MESSAGE)
-
-        assert setup_component(self.hass, device_tracker.DOMAIN, {
             device_tracker.DOMAIN: {
                 CONF_PLATFORM: 'mqtt_json',
                 'devices': {dev_id: topic}
             }
         })
-        fire_mqtt_message(self.hass, topic, location)
+        assert mock_sp.call_count == 1
-        self.hass.block_till_done()
-        state = self.hass.states.get('device_tracker.zanzito')
-        assert state.attributes.get('latitude') == 2.0
-        assert state.attributes.get('longitude') == 1.0
 
-    def test_non_json_message(self):
-        """Test receiving a non JSON message."""
-        dev_id = 'zanzito'
-        topic = 'location/zanzito'
-        location = 'home'
 
-        assert setup_component(self.hass, device_tracker.DOMAIN, {
+async def test_json_message(hass):
-            device_tracker.DOMAIN: {
+    """Test json location message."""
-                CONF_PLATFORM: 'mqtt_json',
+    dev_id = 'zanzito'
-                'devices': {dev_id: topic}
+    topic = 'location/zanzito'
-            }
+    location = json.dumps(LOCATION_MESSAGE)
-        })
 
-        with self.assertLogs(level='ERROR') as test_handle:
+    assert await async_setup_component(hass, device_tracker.DOMAIN, {
-            fire_mqtt_message(self.hass, topic, location)
+        device_tracker.DOMAIN: {
-            self.hass.block_till_done()
+            CONF_PLATFORM: 'mqtt_json',
-            assert "ERROR:homeassistant.components.device_tracker.mqtt_json:" \
+            'devices': {dev_id: topic}
-                "Error parsing JSON payload: home" in \
+        }
-                test_handle.output[0]
+    })
+    async_fire_mqtt_message(hass, topic, location)
+    await hass.async_block_till_done()
+    state = hass.states.get('device_tracker.zanzito')
+    assert state.attributes.get('latitude') == 2.0
+    assert state.attributes.get('longitude') == 1.0
 
-    def test_incomplete_message(self):
-        """Test receiving an incomplete message."""
-        dev_id = 'zanzito'
-        topic = 'location/zanzito'
-        location = json.dumps(LOCATION_MESSAGE_INCOMPLETE)
 
-        assert setup_component(self.hass, device_tracker.DOMAIN, {
+async def test_non_json_message(hass, caplog):
-            device_tracker.DOMAIN: {
+    """Test receiving a non JSON message."""
-                CONF_PLATFORM: 'mqtt_json',
+    dev_id = 'zanzito'
-                'devices': {dev_id: topic}
+    topic = 'location/zanzito'
-            }
+    location = 'home'
-        })
 
-        with self.assertLogs(level='ERROR') as test_handle:
+    assert await async_setup_component(hass, device_tracker.DOMAIN, {
-            fire_mqtt_message(self.hass, topic, location)
+        device_tracker.DOMAIN: {
-            self.hass.block_till_done()
+            CONF_PLATFORM: 'mqtt_json',
-            assert "ERROR:homeassistant.components.device_tracker.mqtt_json:" \
+            'devices': {dev_id: topic}
-                "Skipping update for following data because of missing " \
+        }
-                "or malformatted data: {\"longitude\": 2.0}" in \
+    })
-                test_handle.output[0]
 
-    def test_single_level_wildcard_topic(self):
+    caplog.set_level(logging.ERROR)
-        """Test single level wildcard topic."""
+    caplog.clear()
-        dev_id = 'zanzito'
+    async_fire_mqtt_message(hass, topic, location)
-        subscription = 'location/+/zanzito'
+    await hass.async_block_till_done()
-        topic = 'location/room/zanzito'
+    assert "Error parsing JSON payload: home" in \
-        location = json.dumps(LOCATION_MESSAGE)
+        caplog.text
 
-        assert setup_component(self.hass, device_tracker.DOMAIN, {
-            device_tracker.DOMAIN: {
-                CONF_PLATFORM: 'mqtt_json',
-                'devices': {dev_id: subscription}
-            }
-        })
-        fire_mqtt_message(self.hass, topic, location)
-        self.hass.block_till_done()
-        state = self.hass.states.get('device_tracker.zanzito')
-        assert state.attributes.get('latitude') == 2.0
-        assert state.attributes.get('longitude') == 1.0
 
-    def test_multi_level_wildcard_topic(self):
+async def test_incomplete_message(hass, caplog):
-        """Test multi level wildcard topic."""
+    """Test receiving an incomplete message."""
-        dev_id = 'zanzito'
+    dev_id = 'zanzito'
-        subscription = 'location/#'
+    topic = 'location/zanzito'
-        topic = 'location/zanzito'
+    location = json.dumps(LOCATION_MESSAGE_INCOMPLETE)
-        location = json.dumps(LOCATION_MESSAGE)
 
-        assert setup_component(self.hass, device_tracker.DOMAIN, {
+    assert await async_setup_component(hass, device_tracker.DOMAIN, {
-            device_tracker.DOMAIN: {
+        device_tracker.DOMAIN: {
-                CONF_PLATFORM: 'mqtt_json',
+            CONF_PLATFORM: 'mqtt_json',
-                'devices': {dev_id: subscription}
+            'devices': {dev_id: topic}
-            }
+        }
-        })
+    })
-        fire_mqtt_message(self.hass, topic, location)
-        self.hass.block_till_done()
-        state = self.hass.states.get('device_tracker.zanzito')
-        assert state.attributes.get('latitude') == 2.0
-        assert state.attributes.get('longitude') == 1.0
 
-    def test_single_level_wildcard_topic_not_matching(self):
+    caplog.set_level(logging.ERROR)
-        """Test not matching single level wildcard topic."""
+    caplog.clear()
-        dev_id = 'zanzito'
+    async_fire_mqtt_message(hass, topic, location)
-        entity_id = device_tracker.ENTITY_ID_FORMAT.format(dev_id)
+    await hass.async_block_till_done()
-        subscription = 'location/+/zanzito'
+    assert "Skipping update for following data because of missing " \
-        topic = 'location/zanzito'
+        "or malformatted data: {\"longitude\": 2.0}" in \
-        location = json.dumps(LOCATION_MESSAGE)
+        caplog.text
 
-        assert setup_component(self.hass, device_tracker.DOMAIN, {
-            device_tracker.DOMAIN: {
-                CONF_PLATFORM: 'mqtt_json',
-                'devices': {dev_id: subscription}
-            }
-        })
-        fire_mqtt_message(self.hass, topic, location)
-        self.hass.block_till_done()
-        assert self.hass.states.get(entity_id) is None
 
-    def test_multi_level_wildcard_topic_not_matching(self):
+async def test_single_level_wildcard_topic(hass):
-        """Test not matching multi level wildcard topic."""
+    """Test single level wildcard topic."""
-        dev_id = 'zanzito'
+    dev_id = 'zanzito'
-        entity_id = device_tracker.ENTITY_ID_FORMAT.format(dev_id)
+    subscription = 'location/+/zanzito'
-        subscription = 'location/#'
+    topic = 'location/room/zanzito'
-        topic = 'somewhere/zanzito'
+    location = json.dumps(LOCATION_MESSAGE)
-        location = json.dumps(LOCATION_MESSAGE)
 
-        assert setup_component(self.hass, device_tracker.DOMAIN, {
+    assert await async_setup_component(hass, device_tracker.DOMAIN, {
-            device_tracker.DOMAIN: {
+        device_tracker.DOMAIN: {
-                CONF_PLATFORM: 'mqtt_json',
+            CONF_PLATFORM: 'mqtt_json',
-                'devices': {dev_id: subscription}
+            'devices': {dev_id: subscription}
-            }
+        }
-        })
+    })
-        fire_mqtt_message(self.hass, topic, location)
+    async_fire_mqtt_message(hass, topic, location)
-        self.hass.block_till_done()
+    await hass.async_block_till_done()
-        assert self.hass.states.get(entity_id) is None
+    state = hass.states.get('device_tracker.zanzito')
+    assert state.attributes.get('latitude') == 2.0
+    assert state.attributes.get('longitude') == 1.0
+
+
+async def test_multi_level_wildcard_topic(hass):
+    """Test multi level wildcard topic."""
+    dev_id = 'zanzito'
+    subscription = 'location/#'
+    topic = 'location/zanzito'
+    location = json.dumps(LOCATION_MESSAGE)
+
+    assert await async_setup_component(hass, device_tracker.DOMAIN, {
+        device_tracker.DOMAIN: {
+            CONF_PLATFORM: 'mqtt_json',
+            'devices': {dev_id: subscription}
+        }
+    })
+    async_fire_mqtt_message(hass, topic, location)
+    await hass.async_block_till_done()
+    state = hass.states.get('device_tracker.zanzito')
+    assert state.attributes.get('latitude') == 2.0
+    assert state.attributes.get('longitude') == 1.0
+
+
+async def test_single_level_wildcard_topic_not_matching(hass):
+    """Test not matching single level wildcard topic."""
+    dev_id = 'zanzito'
+    entity_id = device_tracker.ENTITY_ID_FORMAT.format(dev_id)
+    subscription = 'location/+/zanzito'
+    topic = 'location/zanzito'
+    location = json.dumps(LOCATION_MESSAGE)
+
+    assert await async_setup_component(hass, device_tracker.DOMAIN, {
+        device_tracker.DOMAIN: {
+            CONF_PLATFORM: 'mqtt_json',
+            'devices': {dev_id: subscription}
+        }
+    })
+    async_fire_mqtt_message(hass, topic, location)
+    await hass.async_block_till_done()
+    assert hass.states.get(entity_id) is None
+
+
+async def test_multi_level_wildcard_topic_not_matching(hass):
+    """Test not matching multi level wildcard topic."""
+    dev_id = 'zanzito'
+    entity_id = device_tracker.ENTITY_ID_FORMAT.format(dev_id)
+    subscription = 'location/#'
+    topic = 'somewhere/zanzito'
+    location = json.dumps(LOCATION_MESSAGE)
+
+    assert await async_setup_component(hass, device_tracker.DOMAIN, {
+        device_tracker.DOMAIN: {
+            CONF_PLATFORM: 'mqtt_json',
+            'devices': {dev_id: subscription}
+        }
+    })
+    async_fire_mqtt_message(hass, topic, location)
+    await hass.async_block_till_done()
+    assert hass.states.get(entity_id) is None