Migrate emulated_hue tests from unittest to pytest (#55794)

* Migrate emulated_hue tests from unittest to pytest

* Remove unused variables

tests/components/emulated_hue/test_upnp.py

@@ -2,23 +2,19 @@
 import json
 import unittest
 
-from aiohttp.hdrs import CONTENT_TYPE
+from aiohttp import web
 import defusedxml.ElementTree as ET
-import requests
+import pytest
 
-from homeassistant import const, setup
+from homeassistant import setup
 from homeassistant.components import emulated_hue
 from homeassistant.components.emulated_hue import upnp
 from homeassistant.const import CONTENT_TYPE_JSON, HTTP_OK
 
-from tests.common import get_test_home_assistant, get_test_instance_port
+from tests.common import get_test_instance_port
 
-HTTP_SERVER_PORT = get_test_instance_port()
 BRIDGE_SERVER_PORT = get_test_instance_port()
 
-BRIDGE_URL_BASE = f"http://127.0.0.1:{BRIDGE_SERVER_PORT}" + "{}"
-JSON_HEADERS = {CONTENT_TYPE: const.CONTENT_TYPE_JSON}
-
 
 class MockTransport:
     """Mock asyncio transport."""
@@ -32,34 +28,33 @@ class MockTransport:
         self.sends.append((response, addr))
 
 
-class TestEmulatedHue(unittest.TestCase):
+@pytest.fixture
-    """Test the emulated Hue component."""
+def hue_client(aiohttp_client):
+    """Return a hue API client."""
+    app = web.Application()
+    with unittest.mock.patch(
+        "homeassistant.components.emulated_hue.web.Application", return_value=app
+    ):
 
-    hass = None
+        async def client():
+            """Return an authenticated client."""
+            return await aiohttp_client(app)
 
-    @classmethod
+        yield client
-    def setUpClass(cls):
-        """Set up the class."""
-        cls.hass = hass = get_test_home_assistant()
 
-        setup.setup_component(
+
+async def setup_hue(hass):
+    """Set up the emulated_hue integration."""
+    assert await setup.async_setup_component(
         hass,
         emulated_hue.DOMAIN,
         {emulated_hue.DOMAIN: {emulated_hue.CONF_LISTEN_PORT: BRIDGE_SERVER_PORT}},
     )
 
-        cls.hass.start()
 
-    @classmethod
+def test_upnp_discovery_basic():
-    def tearDownClass(cls):
-        """Stop the class."""
-        cls.hass.stop()
-
-    def test_upnp_discovery_basic(self):
     """Tests the UPnP basic discovery response."""
-        upnp_responder_protocol = upnp.UPNPResponderProtocol(
+    upnp_responder_protocol = upnp.UPNPResponderProtocol(None, None, "192.0.2.42", 8080)
-            None, None, "192.0.2.42", 8080
-        )
     mock_transport = MockTransport()
     upnp_responder_protocol.transport = mock_transport
 
@@ -88,11 +83,10 @@ USN: uuid:2f402f80-da50-11e1-9b23-001788255acc
 
     assert mock_transport.sends == [(expected_send, 1234)]
 
-    def test_upnp_discovery_rootdevice(self):
+
+def test_upnp_discovery_rootdevice():
     """Tests the UPnP rootdevice discovery response."""
-        upnp_responder_protocol = upnp.UPNPResponderProtocol(
+    upnp_responder_protocol = upnp.UPNPResponderProtocol(None, None, "192.0.2.42", 8080)
-            None, None, "192.0.2.42", 8080
-        )
     mock_transport = MockTransport()
     upnp_responder_protocol.transport = mock_transport
 
@@ -121,11 +115,10 @@ USN: uuid:2f402f80-da50-11e1-9b23-001788255acc::upnp:rootdevice
 
     assert mock_transport.sends == [(expected_send, 1234)]
 
-    def test_upnp_no_response(self):
+
+def test_upnp_no_response():
     """Tests the UPnP does not response on an invalid request."""
-        upnp_responder_protocol = upnp.UPNPResponderProtocol(
+    upnp_responder_protocol = upnp.UPNPResponderProtocol(None, None, "192.0.2.42", 8080)
-            None, None, "192.0.2.42", 8080
-        )
     mock_transport = MockTransport()
     upnp_responder_protocol.transport = mock_transport
 
@@ -143,52 +136,56 @@ MX:3
 
     assert mock_transport.sends == []
 
-    def test_description_xml(self):
-        """Test the description."""
-        result = requests.get(BRIDGE_URL_BASE.format("/description.xml"), timeout=5)
 
-        assert result.status_code == HTTP_OK
+async def test_description_xml(hass, hue_client):
+    """Test the description."""
+    await setup_hue(hass)
+    client = await hue_client()
+    result = await client.get("/description.xml", timeout=5)
+
+    assert result.status == HTTP_OK
     assert "text/xml" in result.headers["content-type"]
 
-        # Make sure the XML is parsable
     try:
-            root = ET.fromstring(result.text)
+        root = ET.fromstring(await result.text())
         ns = {"s": "urn:schemas-upnp-org:device-1-0"}
         assert root.find("./s:device/s:serialNumber", ns).text == "001788FFFE23BFC2"
     except:  # noqa: E722 pylint: disable=bare-except
-            self.fail("description.xml is not valid XML!")
+        pytest.fail("description.xml is not valid XML!")
 
-    def test_create_username(self):
+
+async def test_create_username(hass, hue_client):
     """Test the creation of an username."""
+    await setup_hue(hass)
+    client = await hue_client()
     request_json = {"devicetype": "my_device"}
 
-        result = requests.post(
+    result = await client.post("/api", data=json.dumps(request_json), timeout=5)
-            BRIDGE_URL_BASE.format("/api"), data=json.dumps(request_json), timeout=5
-        )
 
-        assert result.status_code == HTTP_OK
+    assert result.status == HTTP_OK
     assert CONTENT_TYPE_JSON in result.headers["content-type"]
 
-        resp_json = result.json()
+    resp_json = await result.json()
     success_json = resp_json[0]
 
     assert "success" in success_json
     assert "username" in success_json["success"]
 
-    def test_unauthorized_view(self):
+
+async def test_unauthorized_view(hass, hue_client):
     """Test unauthorized view."""
+    await setup_hue(hass)
+    client = await hue_client()
     request_json = {"devicetype": "my_device"}
 
-        result = requests.get(
+    result = await client.get(
-            BRIDGE_URL_BASE.format("/api/unauthorized"),
+        "/api/unauthorized", data=json.dumps(request_json), timeout=5
-            data=json.dumps(request_json),
-            timeout=5,
     )
 
-        assert result.status_code == HTTP_OK
+    assert result.status == HTTP_OK
     assert CONTENT_TYPE_JSON in result.headers["content-type"]
 
-        resp_json = result.json()
+    resp_json = await result.json()
     assert len(resp_json) == 1
     success_json = resp_json[0]
     assert len(success_json) == 1
@@ -200,12 +197,13 @@ MX:3
     assert "unauthorized user" in error_json["description"]
     assert "1" in error_json["type"]
 
-    def test_valid_username_request(self):
+
+async def test_valid_username_request(hass, hue_client):
     """Test request with a valid username."""
+    await setup_hue(hass)
+    client = await hue_client()
     request_json = {"invalid_key": "my_device"}
 
-        result = requests.post(
+    result = await client.post("/api", data=json.dumps(request_json), timeout=5)
-            BRIDGE_URL_BASE.format("/api"), data=json.dumps(request_json), timeout=5
-        )
 
-        assert result.status_code == 400
+    assert result.status == 400