home-assistant · balloob · May 19, 2017 · May 19, 2017 · May 19, 2017 · May 19, 2017
@@ -150,14 +150,14 @@ def async_setup_platform(p_type, p_config, disc_info=None):
                 scanner = yield from platform.async_get_scanner(
                     hass, {DOMAIN: p_config})
             elif hasattr(platform, 'get_scanner'):
-                scanner = yield from hass.loop.run_in_executor(
-                    None, platform.get_scanner, hass, {DOMAIN: p_config})
+                scanner = yield from hass.async_add_job(
+                    platform.get_scanner, hass, {DOMAIN: p_config})
             elif hasattr(platform, 'async_setup_scanner'):
                 setup = yield from platform.async_setup_scanner(
                     hass, p_config, tracker.async_see, disc_info)
             elif hasattr(platform, 'setup_scanner'):
-                setup = yield from hass.loop.run_in_executor(
-                    None, platform.setup_scanner, hass, p_config, tracker.see,
+                setup = yield from hass.async_add_job(
+                    platform.setup_scanner, hass, p_config, tracker.see,
                     disc_info)
             else:
                 raise HomeAssistantError("Invalid device_tracker platform.")
@@ -209,8 +209,8 @@ def async_see_service(call):
                  ATTR_GPS, ATTR_GPS_ACCURACY, ATTR_BATTERY, ATTR_ATTRIBUTES)}
         yield from tracker.async_see(**args)
 
-    descriptions = yield from hass.loop.run_in_executor(
-        None, load_yaml_config_file,
+    descriptions = yield from hass.async_add_job(
+        load_yaml_config_file,
         os.path.join(os.path.dirname(__file__), 'services.yaml')
     )
     hass.services.async_register(
@@ -322,8 +322,8 @@ def async_update_config(self, path, dev_id, device):
         This method is a coroutine.
         """
         with (yield from self._is_updating):
-            yield from self.hass.loop.run_in_executor(
-                None, update_config, self.hass.config.path(YAML_DEVICES),
+            yield from self.hass.async_add_job(
+                update_config, self.hass.config.path(YAML_DEVICES),
                 dev_id, device)
 
     @asyncio.coroutine
@@ -608,7 +608,7 @@ def async_scan_devices(self) -> Any:
 
         This method must be run in the event loop and returns a coroutine.
         """
-        return self.hass.loop.run_in_executor(None, self.scan_devices)
+        return self.hass.async_add_job(self.scan_devices)
 
     def get_device_name(self, mac: str) -> str:
        """Get device name from mac."""
@@ -619,7 +619,7 @@ def async_get_device_name(self, mac: str) -> Any:
 
         This method must be run in the event loop and returns a coroutine.
         """
-        return self.hass.loop.run_in_executor(None, self.get_device_name, mac)
+        return self.hass.async_add_job(self.get_device_name, mac)
 
 
 def load_config(path: str, hass: HomeAssistantType, consider_home: timedelta):
@@ -650,8 +650,8 @@ def async_load_config(path: str, hass: HomeAssistantType,
     try:
         result = []
         try:
-            devices = yield from hass.loop.run_in_executor(
-                None, load_yaml_config_file, path)
+            devices = yield from hass.async_add_job(
+                load_yaml_config_file, path)
         except HomeAssistantError as err:
             _LOGGER.error("Unable to load %s: %s", path, str(err))
             return []

@@ -1,169 +1,151 @@
 """The tests for the Home Assistant HTTP component."""
 # pylint: disable=protected-access
-import logging
+import asyncio
 from ipaddress import ip_address, ip_network
 from unittest.mock import patch
 
-import requests
+import pytest
 
-from homeassistant import setup, const
+from homeassistant import const
+from homeassistant.setup import async_setup_component
 import homeassistant.components.http as http
 from homeassistant.components.http.const import (
     KEY_TRUSTED_NETWORKS, KEY_USE_X_FORWARDED_FOR, HTTP_HEADER_X_FORWARDED_FOR)
 
-from tests.common import get_test_instance_port, get_test_home_assistant
-
 API_PASSWORD = 'test1234'
-SERVER_PORT = get_test_instance_port()
-HTTP_BASE = '127.0.0.1:{}'.format(SERVER_PORT)
-HTTP_BASE_URL = 'http://{}'.format(HTTP_BASE)
-HA_HEADERS = {
-    const.HTTP_HEADER_HA_AUTH: API_PASSWORD,
-    const.HTTP_HEADER_CONTENT_TYPE: const.CONTENT_TYPE_JSON,
-}
+
 # Don't add 127.0.0.1/::1 as trusted, as it may interfere with other test cases
 TRUSTED_NETWORKS = ['192.0.2.0/24', '2001:DB8:ABCD::/48', '100.64.0.1',
                     'FD01:DB8::1']
 TRUSTED_ADDRESSES = ['100.64.0.1', '192.0.2.100', 'FD01:DB8::1',
                      '2001:DB8:ABCD::1']
 UNTRUSTED_ADDRESSES = ['198.51.100.1', '2001:DB8:FA1::1', '127.0.0.1', '::1']
 
-hass = None
-
-
-def _url(path=''):
-    """Helper method to generate URLs."""
-    return HTTP_BASE_URL + path
-
 
-# pylint: disable=invalid-name
-def setUpModule():
-    """Initialize a Home Assistant server."""
-    global hass
-
-    hass = get_test_home_assistant()
-
-    setup.setup_component(
-        hass, http.DOMAIN, {
-            http.DOMAIN: {
-                http.CONF_API_PASSWORD: API_PASSWORD,
-                http.CONF_SERVER_PORT: SERVER_PORT,
-            }
+@pytest.fixture
+def mock_api_client(hass, test_client):
+    """Start the Hass HTTP component."""
+    hass.loop.run_until_complete(async_setup_component(hass, 'api', {
+        'http': {
+            http.CONF_API_PASSWORD: API_PASSWORD,
         }
-    )
+    }))
+    return hass.loop.run_until_complete(test_client(hass.http.app))
 
-    setup.setup_component(hass, 'api')
 
+@pytest.fixture
+def mock_trusted_networks(hass, mock_api_client):
+    """Mock trusted networks."""
     hass.http.app[KEY_TRUSTED_NETWORKS] = [
         ip_network(trusted_network)
         for trusted_network in TRUSTED_NETWORKS]
 
-    hass.start()
 
+@asyncio.coroutine
+def test_access_denied_without_password(mock_api_client):
+    """Test access without password."""
+    resp = yield from mock_api_client.get(const.URL_API)
+    assert resp.status == 401
 
-# pylint: disable=invalid-name
-def tearDownModule():
-    """Stop the Home Assistant server."""
-    hass.stop()
 
+@asyncio.coroutine
+def test_access_denied_with_wrong_password_in_header(mock_api_client):
+    """Test access with wrong password."""
+    resp = yield from mock_api_client.get(const.URL_API, headers={
+        const.HTTP_HEADER_HA_AUTH: 'wrongpassword'
+    })
+    assert resp.status == 401
 
-class TestHttp:
-    """Test HTTP component."""
 
-    def test_access_denied_without_password(self):
-        """Test access without password."""
-        req = requests.get(_url(const.URL_API))
+@asyncio.coroutine
+def test_access_denied_with_x_forwarded_for(hass, mock_api_client,
+                                            mock_trusted_networks):
+    """Test access denied through the X-Forwarded-For http header."""
+    hass.http.use_x_forwarded_for = True
+    for remote_addr in UNTRUSTED_ADDRESSES:
+        resp = yield from mock_api_client.get(const.URL_API, headers={
+            HTTP_HEADER_X_FORWARDED_FOR: remote_addr})
 
-        assert req.status_code == 401
+        assert resp.status == 401, \
+            "{} shouldn't be trusted".format(remote_addr)
 
-    def test_access_denied_with_wrong_password_in_header(self):
-        """Test access with wrong password."""
-        req = requests.get(
-            _url(const.URL_API),
-            headers={const.HTTP_HEADER_HA_AUTH: 'wrongpassword'})
 
-        assert req.status_code == 401
+@asyncio.coroutine
+def test_access_denied_with_untrusted_ip(mock_api_client,
+                                         mock_trusted_networks):
+    """Test access with an untrusted ip address."""
+    for remote_addr in UNTRUSTED_ADDRESSES:
+        with patch('homeassistant.components.http.'
+                   'util.get_real_ip',
+                   return_value=ip_address(remote_addr)):
+            resp = yield from mock_api_client.get(
+                const.URL_API, params={'api_password': ''})
 
-    def test_access_denied_with_x_forwarded_for(self, caplog):
-        """Test access denied through the X-Forwarded-For http header."""
-        hass.http.use_x_forwarded_for = True
-        for remote_addr in UNTRUSTED_ADDRESSES:
-            req = requests.get(_url(const.URL_API), headers={
-                HTTP_HEADER_X_FORWARDED_FOR: remote_addr})
-
-            assert req.status_code == 401, \
+            assert resp.status == 401, \
                 "{} shouldn't be trusted".format(remote_addr)
 
-    def test_access_denied_with_untrusted_ip(self, caplog):
-        """Test access with an untrusted ip address."""
-        for remote_addr in UNTRUSTED_ADDRESSES:
-            with patch('homeassistant.components.http.'
-                       'util.get_real_ip',
-                       return_value=ip_address(remote_addr)):
-                req = requests.get(
-                    _url(const.URL_API), params={'api_password': ''})
 
-                assert req.status_code == 401, \
-                    "{} shouldn't be trusted".format(remote_addr)
+@asyncio.coroutine
+def test_access_with_password_in_header(mock_api_client, caplog):
+    """Test access with password in URL."""
+    # Hide logging from requests package that we use to test logging
+    req = yield from mock_api_client.get(
+        const.URL_API, headers={const.HTTP_HEADER_HA_AUTH: API_PASSWORD})
+
+    assert req.status == 200
 
-    def test_access_with_password_in_header(self, caplog):
-        """Test access with password in URL."""
-        # Hide logging from requests package that we use to test logging
-        caplog.set_level(
-            logging.WARNING, logger='requests.packages.urllib3.connectionpool')
+    logs = caplog.text
 
-        req = requests.get(
-            _url(const.URL_API),
-            headers={const.HTTP_HEADER_HA_AUTH: API_PASSWORD})
+    assert const.URL_API in logs
+    assert API_PASSWORD not in logs
 
-        assert req.status_code == 200
 
-        logs = caplog.text
+@asyncio.coroutine
+def test_access_denied_with_wrong_password_in_url(mock_api_client):
+    """Test access with wrong password."""
+    resp = yield from mock_api_client.get(
+        const.URL_API, params={'api_password': 'wrongpassword'})
 
-        assert const.URL_API in logs
-        assert API_PASSWORD not in logs
+    assert resp.status == 401
 
-    def test_access_denied_with_wrong_password_in_url(self):
-        """Test access with wrong password."""
-        req = requests.get(
-            _url(const.URL_API), params={'api_password': 'wrongpassword'})
 
-        assert req.status_code == 401
+@asyncio.coroutine
+def test_access_with_password_in_url(mock_api_client, caplog):
+    """Test access with password in URL."""
+    req = yield from mock_api_client.get(
+        const.URL_API, params={'api_password': API_PASSWORD})
 
-    def test_access_with_password_in_url(self, caplog):
-        """Test access with password in URL."""
-        # Hide logging from requests package that we use to test logging
-        caplog.set_level(
-            logging.WARNING, logger='requests.packages.urllib3.connectionpool')
+    assert req.status == 200
 
-        req = requests.get(
-            _url(const.URL_API), params={'api_password': API_PASSWORD})
+    logs = caplog.text
 
-        assert req.status_code == 200
+    assert const.URL_API in logs
+    assert API_PASSWORD not in logs
 
-        logs = caplog.text
 
-        assert const.URL_API in logs
-        assert API_PASSWORD not in logs
+@asyncio.coroutine
+def test_access_granted_with_x_forwarded_for(hass, mock_api_client, caplog,
+                                             mock_trusted_networks):
+    """Test access denied through the X-Forwarded-For http header."""
+    hass.http.app[KEY_USE_X_FORWARDED_FOR] = True
+    for remote_addr in TRUSTED_ADDRESSES:
+        resp = yield from mock_api_client.get(const.URL_API, headers={
+            HTTP_HEADER_X_FORWARDED_FOR: remote_addr})
 
-    def test_access_granted_with_x_forwarded_for(self, caplog):
-        """Test access denied through the X-Forwarded-For http header."""
-        hass.http.app[KEY_USE_X_FORWARDED_FOR] = True
-        for remote_addr in TRUSTED_ADDRESSES:
-            req = requests.get(_url(const.URL_API), headers={
-                HTTP_HEADER_X_FORWARDED_FOR: remote_addr})
+        assert resp.status == 200, \
+            "{} should be trusted".format(remote_addr)
 
-            assert req.status_code == 200, \
-                "{} should be trusted".format(remote_addr)
 
-    def test_access_granted_with_trusted_ip(self, caplog):
-        """Test access with trusted addresses."""
-        for remote_addr in TRUSTED_ADDRESSES:
-            with patch('homeassistant.components.http.'
-                       'auth.get_real_ip',
-                       return_value=ip_address(remote_addr)):
-                req = requests.get(
-                    _url(const.URL_API), params={'api_password': ''})
+@asyncio.coroutine
+def test_access_granted_with_trusted_ip(mock_api_client, caplog,
+                                        mock_trusted_networks):
+    """Test access with trusted addresses."""
+    for remote_addr in TRUSTED_ADDRESSES:
+        with patch('homeassistant.components.http.'
+                   'auth.get_real_ip',
+                   return_value=ip_address(remote_addr)):
+            resp = yield from mock_api_client.get(
+                const.URL_API, params={'api_password': ''})
 
-                assert req.status_code == 200, \
-                    '{} should be trusted'.format(remote_addr)
+            assert resp.status == 200, \
+                '{} should be trusted'.format(remote_addr)