Rest test style (#42032)

tests/components/rest/test_switch.py

@@ -16,254 +16,239 @@ from homeassistant.const import (
     HTTP_OK,
 )
 from homeassistant.helpers.template import Template
-from homeassistant.setup import setup_component
+from homeassistant.setup import async_setup_component
 
-from tests.common import assert_setup_component, get_test_home_assistant
+from tests.common import assert_setup_component
+
+"""Tests for setting up the REST switch platform."""
+
+NAME = "foo"
+METHOD = "post"
+RESOURCE = "http://localhost/"
+STATE_RESOURCE = RESOURCE
+HEADERS = {"Content-type": CONTENT_TYPE_JSON}
+AUTH = None
 
 
-class TestRestSwitchSetup:
+async def test_setup_missing_config(hass):
-    """Tests for setting up the REST switch platform."""
+    """Test setup with configuration missing required entries."""
+    assert not await rest.async_setup_platform(hass, {CONF_PLATFORM: rest.DOMAIN}, None)
 
-    def setup_method(self):
-        """Set up things to be run when tests are started."""
-        self.hass = get_test_home_assistant()
 
-    def teardown_method(self):
+async def test_setup_missing_schema(hass):
-        """Stop everything that was started."""
+    """Test setup with resource missing schema."""
-        self.hass.stop()
+    assert not await rest.async_setup_platform(
+        hass,
+        {CONF_PLATFORM: rest.DOMAIN, CONF_RESOURCE: "localhost"},
+        None,
+    )
 
-    def test_setup_missing_config(self):
-        """Test setup with configuration missing required entries."""
-        assert not asyncio.run_coroutine_threadsafe(
-            rest.async_setup_platform(self.hass, {CONF_PLATFORM: rest.DOMAIN}, None),
-            self.hass.loop,
-        ).result()
 
-    def test_setup_missing_schema(self):
+async def test_setup_failed_connect(hass, aioclient_mock):
-        """Test setup with resource missing schema."""
+    """Test setup when connection error occurs."""
-        assert not asyncio.run_coroutine_threadsafe(
+    aioclient_mock.get("http://localhost", exc=aiohttp.ClientError)
-            rest.async_setup_platform(
+    assert not await rest.async_setup_platform(
-                self.hass,
+        hass,
-                {CONF_PLATFORM: rest.DOMAIN, CONF_RESOURCE: "localhost"},
+        {CONF_PLATFORM: rest.DOMAIN, CONF_RESOURCE: "http://localhost"},
-                None,
+        None,
-            ),
+    )
-            self.hass.loop,
-        ).result()
 
-    def test_setup_failed_connect(self, aioclient_mock):
-        """Test setup when connection error occurs."""
-        aioclient_mock.get("http://localhost", exc=aiohttp.ClientError)
-        assert not asyncio.run_coroutine_threadsafe(
-            rest.async_setup_platform(
-                self.hass,
-                {CONF_PLATFORM: rest.DOMAIN, CONF_RESOURCE: "http://localhost"},
-                None,
-            ),
-            self.hass.loop,
-        ).result()
 
-    def test_setup_timeout(self, aioclient_mock):
+async def test_setup_timeout(hass, aioclient_mock):
-        """Test setup when connection timeout occurs."""
+    """Test setup when connection timeout occurs."""
-        aioclient_mock.get("http://localhost", exc=asyncio.TimeoutError())
+    aioclient_mock.get("http://localhost", exc=asyncio.TimeoutError())
-        assert not asyncio.run_coroutine_threadsafe(
+    assert not await rest.async_setup_platform(
-            rest.async_setup_platform(
+        hass,
-                self.hass,
+        {CONF_PLATFORM: rest.DOMAIN, CONF_RESOURCE: "http://localhost"},
-                {CONF_PLATFORM: rest.DOMAIN, CONF_RESOURCE: "http://localhost"},
+        None,
-                None,
+    )
-            ),
-            self.hass.loop,
-        ).result()
 
-    def test_setup_minimum(self, aioclient_mock):
-        """Test setup with minimum configuration."""
-        aioclient_mock.get("http://localhost", status=HTTP_OK)
-        with assert_setup_component(1, SWITCH_DOMAIN):
-            assert setup_component(
-                self.hass,
-                SWITCH_DOMAIN,
-                {
-                    SWITCH_DOMAIN: {
-                        CONF_PLATFORM: rest.DOMAIN,
-                        CONF_RESOURCE: "http://localhost",
-                    }
-                },
-            )
-        assert aioclient_mock.call_count == 1
 
-    def test_setup(self, aioclient_mock):
+async def test_setup_minimum(hass, aioclient_mock):
-        """Test setup with valid configuration."""
+    """Test setup with minimum configuration."""
-        aioclient_mock.get("http://localhost", status=HTTP_OK)
+    aioclient_mock.get("http://localhost", status=HTTP_OK)
-        assert setup_component(
+    with assert_setup_component(1, SWITCH_DOMAIN):
-            self.hass,
+        assert await async_setup_component(
+            hass,
             SWITCH_DOMAIN,
             {
                 SWITCH_DOMAIN: {
                     CONF_PLATFORM: rest.DOMAIN,
-                    CONF_NAME: "foo",
                     CONF_RESOURCE: "http://localhost",
-                    CONF_HEADERS: {"Content-type": CONTENT_TYPE_JSON},
-                    rest.CONF_BODY_ON: "custom on text",
-                    rest.CONF_BODY_OFF: "custom off text",
                 }
             },
         )
-        assert aioclient_mock.call_count == 1
+    assert aioclient_mock.call_count == 1
-        assert_setup_component(1, SWITCH_DOMAIN)
-
-    def test_setup_with_state_resource(self, aioclient_mock):
-        """Test setup with valid configuration."""
-        aioclient_mock.get("http://localhost", status=HTTP_NOT_FOUND)
-        aioclient_mock.get("http://localhost/state", status=HTTP_OK)
-        assert setup_component(
-            self.hass,
-            SWITCH_DOMAIN,
-            {
-                SWITCH_DOMAIN: {
-                    CONF_PLATFORM: rest.DOMAIN,
-                    CONF_NAME: "foo",
-                    CONF_RESOURCE: "http://localhost",
-                    rest.CONF_STATE_RESOURCE: "http://localhost/state",
-                    CONF_HEADERS: {"Content-type": CONTENT_TYPE_JSON},
-                    rest.CONF_BODY_ON: "custom on text",
-                    rest.CONF_BODY_OFF: "custom off text",
-                }
-            },
-        )
-        assert aioclient_mock.call_count == 1
-        assert_setup_component(1, SWITCH_DOMAIN)
 
 
-class TestRestSwitch:
+async def test_setup(hass, aioclient_mock):
-    """Tests for REST switch platform."""
+    """Test setup with valid configuration."""
+    aioclient_mock.get("http://localhost", status=HTTP_OK)
+    assert await async_setup_component(
+        hass,
+        SWITCH_DOMAIN,
+        {
+            SWITCH_DOMAIN: {
+                CONF_PLATFORM: rest.DOMAIN,
+                CONF_NAME: "foo",
+                CONF_RESOURCE: "http://localhost",
+                CONF_HEADERS: {"Content-type": CONTENT_TYPE_JSON},
+                rest.CONF_BODY_ON: "custom on text",
+                rest.CONF_BODY_OFF: "custom off text",
+            }
+        },
+    )
+    assert aioclient_mock.call_count == 1
+    assert_setup_component(1, SWITCH_DOMAIN)
 
-    def setup_method(self):
-        """Set up things to be run when tests are started."""
-        self.hass = get_test_home_assistant()
-        self.name = "foo"
-        self.method = "post"
-        self.resource = "http://localhost/"
-        self.state_resource = self.resource
-        self.headers = {"Content-type": CONTENT_TYPE_JSON}
-        self.auth = None
-        self.body_on = Template("on", self.hass)
-        self.body_off = Template("off", self.hass)
-        self.switch = rest.RestSwitch(
-            self.name,
-            self.resource,
-            self.state_resource,
-            self.method,
-            self.headers,
-            self.auth,
-            self.body_on,
-            self.body_off,
-            None,
-            10,
-            True,
-        )
-        self.switch.hass = self.hass
 
-    def teardown_method(self):
+async def test_setup_with_state_resource(hass, aioclient_mock):
-        """Stop everything that was started."""
+    """Test setup with valid configuration."""
-        self.hass.stop()
+    aioclient_mock.get("http://localhost", status=HTTP_NOT_FOUND)
+    aioclient_mock.get("http://localhost/state", status=HTTP_OK)
+    assert await async_setup_component(
+        hass,
+        SWITCH_DOMAIN,
+        {
+            SWITCH_DOMAIN: {
+                CONF_PLATFORM: rest.DOMAIN,
+                CONF_NAME: "foo",
+                CONF_RESOURCE: "http://localhost",
+                rest.CONF_STATE_RESOURCE: "http://localhost/state",
+                CONF_HEADERS: {"Content-type": CONTENT_TYPE_JSON},
+                rest.CONF_BODY_ON: "custom on text",
+                rest.CONF_BODY_OFF: "custom off text",
+            }
+        },
+    )
+    assert aioclient_mock.call_count == 1
+    assert_setup_component(1, SWITCH_DOMAIN)
 
-    def test_name(self):
-        """Test the name."""
-        assert self.name == self.switch.name
 
-    def test_is_on_before_update(self):
+"""Tests for REST switch platform."""
-        """Test is_on in initial state."""
-        assert self.switch.is_on is None
 
-    def test_turn_on_success(self, aioclient_mock):
-        """Test turn_on."""
-        aioclient_mock.post(self.resource, status=HTTP_OK)
-        asyncio.run_coroutine_threadsafe(
-            self.switch.async_turn_on(), self.hass.loop
-        ).result()
 
-        assert self.body_on.template == aioclient_mock.mock_calls[-1][2].decode()
+def _setup_test_switch(hass):
-        assert self.switch.is_on
+    body_on = Template("on", hass)
+    body_off = Template("off", hass)
+    switch = rest.RestSwitch(
+        NAME,
+        RESOURCE,
+        STATE_RESOURCE,
+        METHOD,
+        HEADERS,
+        AUTH,
+        body_on,
+        body_off,
+        None,
+        10,
+        True,
+    )
+    switch.hass = hass
+    return switch, body_on, body_off
 
-    def test_turn_on_status_not_ok(self, aioclient_mock):
-        """Test turn_on when error status returned."""
-        aioclient_mock.post(self.resource, status=HTTP_INTERNAL_SERVER_ERROR)
-        asyncio.run_coroutine_threadsafe(
-            self.switch.async_turn_on(), self.hass.loop
-        ).result()
 
-        assert self.body_on.template == aioclient_mock.mock_calls[-1][2].decode()
+def test_name(hass):
-        assert self.switch.is_on is None
+    """Test the name."""
+    switch, body_on, body_off = _setup_test_switch(hass)
+    assert NAME == switch.name
 
-    def test_turn_on_timeout(self, aioclient_mock):
-        """Test turn_on when timeout occurs."""
-        aioclient_mock.post(self.resource, status=HTTP_INTERNAL_SERVER_ERROR)
-        asyncio.run_coroutine_threadsafe(
-            self.switch.async_turn_on(), self.hass.loop
-        ).result()
 
-        assert self.switch.is_on is None
+def test_is_on_before_update(hass):
+    """Test is_on in initial state."""
+    switch, body_on, body_off = _setup_test_switch(hass)
+    assert switch.is_on is None
 
-    def test_turn_off_success(self, aioclient_mock):
-        """Test turn_off."""
-        aioclient_mock.post(self.resource, status=HTTP_OK)
-        asyncio.run_coroutine_threadsafe(
-            self.switch.async_turn_off(), self.hass.loop
-        ).result()
 
-        assert self.body_off.template == aioclient_mock.mock_calls[-1][2].decode()
+async def test_turn_on_success(hass, aioclient_mock):
-        assert not self.switch.is_on
+    """Test turn_on."""
+    aioclient_mock.post(RESOURCE, status=HTTP_OK)
+    switch, body_on, body_off = _setup_test_switch(hass)
+    await switch.async_turn_on()
 
-    def test_turn_off_status_not_ok(self, aioclient_mock):
+    assert body_on.template == aioclient_mock.mock_calls[-1][2].decode()
-        """Test turn_off when error status returned."""
+    assert switch.is_on
-        aioclient_mock.post(self.resource, status=HTTP_INTERNAL_SERVER_ERROR)
-        asyncio.run_coroutine_threadsafe(
-            self.switch.async_turn_off(), self.hass.loop
-        ).result()
 
-        assert self.body_off.template == aioclient_mock.mock_calls[-1][2].decode()
-        assert self.switch.is_on is None
 
-    def test_turn_off_timeout(self, aioclient_mock):
+async def test_turn_on_status_not_ok(hass, aioclient_mock):
-        """Test turn_off when timeout occurs."""
+    """Test turn_on when error status returned."""
-        aioclient_mock.post(self.resource, exc=asyncio.TimeoutError())
+    aioclient_mock.post(RESOURCE, status=HTTP_INTERNAL_SERVER_ERROR)
-        asyncio.run_coroutine_threadsafe(
+    switch, body_on, body_off = _setup_test_switch(hass)
-            self.switch.async_turn_on(), self.hass.loop
+    await switch.async_turn_on()
-        ).result()
 
-        assert self.switch.is_on is None
+    assert body_on.template == aioclient_mock.mock_calls[-1][2].decode()
+    assert switch.is_on is None
 
-    def test_update_when_on(self, aioclient_mock):
-        """Test update when switch is on."""
-        aioclient_mock.get(self.resource, text=self.body_on.template)
-        asyncio.run_coroutine_threadsafe(
-            self.switch.async_update(), self.hass.loop
-        ).result()
 
-        assert self.switch.is_on
+async def test_turn_on_timeout(hass, aioclient_mock):
+    """Test turn_on when timeout occurs."""
+    aioclient_mock.post(RESOURCE, status=HTTP_INTERNAL_SERVER_ERROR)
+    switch, body_on, body_off = _setup_test_switch(hass)
+    await switch.async_turn_on()
 
-    def test_update_when_off(self, aioclient_mock):
+    assert switch.is_on is None
-        """Test update when switch is off."""
-        aioclient_mock.get(self.resource, text=self.body_off.template)
-        asyncio.run_coroutine_threadsafe(
-            self.switch.async_update(), self.hass.loop
-        ).result()
 
-        assert not self.switch.is_on
 
-    def test_update_when_unknown(self, aioclient_mock):
+async def test_turn_off_success(hass, aioclient_mock):
-        """Test update when unknown status returned."""
+    """Test turn_off."""
-        aioclient_mock.get(self.resource, text="unknown status")
+    aioclient_mock.post(RESOURCE, status=HTTP_OK)
-        asyncio.run_coroutine_threadsafe(
+    switch, body_on, body_off = _setup_test_switch(hass)
-            self.switch.async_update(), self.hass.loop
+    await switch.async_turn_off()
-        ).result()
 
-        assert self.switch.is_on is None
+    assert body_off.template == aioclient_mock.mock_calls[-1][2].decode()
+    assert not switch.is_on
 
-    def test_update_timeout(self, aioclient_mock):
-        """Test update when timeout occurs."""
-        aioclient_mock.get(self.resource, exc=asyncio.TimeoutError())
-        asyncio.run_coroutine_threadsafe(
-            self.switch.async_update(), self.hass.loop
-        ).result()
 
-        assert self.switch.is_on is None
+async def test_turn_off_status_not_ok(hass, aioclient_mock):
+    """Test turn_off when error status returned."""
+    aioclient_mock.post(RESOURCE, status=HTTP_INTERNAL_SERVER_ERROR)
+    switch, body_on, body_off = _setup_test_switch(hass)
+    await switch.async_turn_off()
+
+    assert body_off.template == aioclient_mock.mock_calls[-1][2].decode()
+    assert switch.is_on is None
+
+
+async def test_turn_off_timeout(hass, aioclient_mock):
+    """Test turn_off when timeout occurs."""
+    aioclient_mock.post(RESOURCE, exc=asyncio.TimeoutError())
+    switch, body_on, body_off = _setup_test_switch(hass)
+    await switch.async_turn_on()
+
+    assert switch.is_on is None
+
+
+async def test_update_when_on(hass, aioclient_mock):
+    """Test update when switch is on."""
+    switch, body_on, body_off = _setup_test_switch(hass)
+    aioclient_mock.get(RESOURCE, text=body_on.template)
+    await switch.async_update()
+
+    assert switch.is_on
+
+
+async def test_update_when_off(hass, aioclient_mock):
+    """Test update when switch is off."""
+    switch, body_on, body_off = _setup_test_switch(hass)
+    aioclient_mock.get(RESOURCE, text=body_off.template)
+    await switch.async_update()
+
+    assert not switch.is_on
+
+
+async def test_update_when_unknown(hass, aioclient_mock):
+    """Test update when unknown status returned."""
+    aioclient_mock.get(RESOURCE, text="unknown status")
+    switch, body_on, body_off = _setup_test_switch(hass)
+    await switch.async_update()
+
+    assert switch.is_on is None
+
+
+async def test_update_timeout(hass, aioclient_mock):
+    """Test update when timeout occurs."""
+    aioclient_mock.get(RESOURCE, exc=asyncio.TimeoutError())
+    switch, body_on, body_off = _setup_test_switch(hass)
+    await switch.async_update()
+
+    assert switch.is_on is None