Convert last media player tests to async (#64572)

tests/components/blackbird/test_media_player.py

@@ -1,6 +1,5 @@
 """The tests for the Monoprice Blackbird media player platform."""
 from collections import defaultdict
-import unittest
 from unittest import mock
 
 import pytest
@@ -19,8 +18,6 @@ from homeassistant.components.media_player.const import (
 )
 from homeassistant.const import STATE_OFF, STATE_ON
 
-import tests.common
-
 
 class AttrDict(dict):
     """Helper class for mocking attributes."""
@@ -60,10 +57,7 @@ class MockBlackbird:
         self.zones[3].av = source_idx
 
 
-class TestBlackbirdSchema(unittest.TestCase):
+def test_valid_serial_schema():
-    """Test Blackbird schema."""
-
-    def test_valid_serial_schema(self):
     """Test valid schema."""
     valid_schema = {
         "platform": "blackbird",
@@ -91,7 +85,8 @@ class TestBlackbirdSchema(unittest.TestCase):
     }
     PLATFORM_SCHEMA(valid_schema)
 
-    def test_valid_socket_schema(self):
+
+def test_valid_socket_schema():
     """Test valid schema."""
     valid_schema = {
         "platform": "blackbird",
@@ -112,7 +107,8 @@ class TestBlackbirdSchema(unittest.TestCase):
     }
     PLATFORM_SCHEMA(valid_schema)
 
-    def test_invalid_schemas(self):
+
+def test_invalid_schemas():
     """Test invalid schemas."""
     schemas = (
         {},  # Empty
@@ -171,21 +167,22 @@ class TestBlackbirdSchema(unittest.TestCase):
             PLATFORM_SCHEMA(value)
 
 
-class TestBlackbirdMediaPlayer(unittest.TestCase):
+@pytest.fixture
-    """Test the media_player module."""
+def mock_blackbird():
+    """Return a mock blackbird instance."""
+    return MockBlackbird()
 
-    def setUp(self):
+
-        """Set up the test case."""
+@pytest.fixture
-        self.blackbird = MockBlackbird()
+async def setup_blackbird(hass, mock_blackbird):
-        self.hass = tests.common.get_test_home_assistant()
+    """Set up blackbird."""
-        self.hass.start()
-        # Note, source dictionary is unsorted!
     with mock.patch(
         "homeassistant.components.blackbird.media_player.get_blackbird",
-            new=lambda *a: self.blackbird,
+        new=lambda *a: mock_blackbird,
     ):
-            setup_platform(
+        await hass.async_add_executor_job(
-                self.hass,
+            setup_platform,
+            hass,
             {
                 "platform": "blackbird",
                 "port": "/dev/ttyUSB0",
@@ -199,32 +196,37 @@ class TestBlackbirdMediaPlayer(unittest.TestCase):
             lambda *args, **kwargs: None,
             {},
         )
-            self.hass.block_till_done()
+        await hass.async_block_till_done()
-        self.media_player = self.hass.data[DATA_BLACKBIRD]["/dev/ttyUSB0-3"]
-        self.media_player.hass = self.hass
-        self.media_player.entity_id = "media_player.zone_3"
-        self.addCleanup(self.tear_down_cleanup)
 
-    def tear_down_cleanup(self):
-        """Tear down the test case."""
-        self.hass.stop()
 
-    def test_setup_platform(self, *args):
+@pytest.fixture
+def media_player_entity(hass, setup_blackbird):
+    """Return the media player entity."""
+    media_player = hass.data[DATA_BLACKBIRD]["/dev/ttyUSB0-3"]
+    media_player.hass = hass
+    media_player.entity_id = "media_player.zone_3"
+    return media_player
+
+
+async def test_setup_platform(hass, setup_blackbird):
     """Test setting up platform."""
     # One service must be registered
-        assert self.hass.services.has_service(DOMAIN, SERVICE_SETALLZONES)
+    assert hass.services.has_service(DOMAIN, SERVICE_SETALLZONES)
-        assert len(self.hass.data[DATA_BLACKBIRD]) == 1
+    assert len(hass.data[DATA_BLACKBIRD]) == 1
-        assert self.hass.data[DATA_BLACKBIRD]["/dev/ttyUSB0-3"].name == "Zone name"
+    assert hass.data[DATA_BLACKBIRD]["/dev/ttyUSB0-3"].name == "Zone name"
 
-    def test_setallzones_service_call_with_entity_id(self):
+
+async def test_setallzones_service_call_with_entity_id(
+    hass, media_player_entity, mock_blackbird
+):
     """Test set all zone source service call with entity id."""
-        self.media_player.update()
+    await hass.async_add_executor_job(media_player_entity.update)
-        assert self.media_player.name == "Zone name"
+    assert media_player_entity.name == "Zone name"
-        assert self.media_player.state == STATE_ON
+    assert media_player_entity.state == STATE_ON
-        assert self.media_player.source == "one"
+    assert media_player_entity.source == "one"
 
     # Call set all zones service
-        self.hass.services.call(
+    await hass.services.async_call(
         DOMAIN,
         SERVICE_SETALLZONES,
         {"entity_id": "media_player.zone_3", "source": "three"},
@@ -232,111 +234,124 @@ class TestBlackbirdMediaPlayer(unittest.TestCase):
     )
 
     # Check that source was changed
-        assert self.blackbird.zones[3].av == 3
+    assert mock_blackbird.zones[3].av == 3
-        self.media_player.update()
+    await hass.async_add_executor_job(media_player_entity.update)
-        assert self.media_player.source == "three"
+    assert media_player_entity.source == "three"
 
-    def test_setallzones_service_call_without_entity_id(self):
+
+async def test_setallzones_service_call_without_entity_id(
+    mock_blackbird, hass, media_player_entity
+):
     """Test set all zone source service call without entity id."""
-        self.media_player.update()
+    await hass.async_add_executor_job(media_player_entity.update)
-        assert self.media_player.name == "Zone name"
+    assert media_player_entity.name == "Zone name"
-        assert self.media_player.state == STATE_ON
+    assert media_player_entity.state == STATE_ON
-        assert self.media_player.source == "one"
+    assert media_player_entity.source == "one"
 
     # Call set all zones service
-        self.hass.services.call(
+    await hass.services.async_call(
         DOMAIN, SERVICE_SETALLZONES, {"source": "three"}, blocking=True
     )
 
     # Check that source was changed
-        assert self.blackbird.zones[3].av == 3
+    assert mock_blackbird.zones[3].av == 3
-        self.media_player.update()
+    await hass.async_add_executor_job(media_player_entity.update)
-        assert self.media_player.source == "three"
+    assert media_player_entity.source == "three"
 
-    def test_update(self):
+
+async def test_update(hass, media_player_entity):
     """Test updating values from blackbird."""
-        assert self.media_player.state is None
+    assert media_player_entity.state is None
-        assert self.media_player.source is None
+    assert media_player_entity.source is None
 
-        self.media_player.update()
+    await hass.async_add_executor_job(media_player_entity.update)
 
-        assert self.media_player.state == STATE_ON
+    assert media_player_entity.state == STATE_ON
-        assert self.media_player.source == "one"
+    assert media_player_entity.source == "one"
 
-    def test_name(self):
+
+async def test_name(media_player_entity):
     """Test name property."""
-        assert self.media_player.name == "Zone name"
+    assert media_player_entity.name == "Zone name"
 
-    def test_state(self):
+
+async def test_state(hass, media_player_entity, mock_blackbird):
     """Test state property."""
-        assert self.media_player.state is None
+    assert media_player_entity.state is None
 
-        self.media_player.update()
+    await hass.async_add_executor_job(media_player_entity.update)
-        assert self.media_player.state == STATE_ON
+    assert media_player_entity.state == STATE_ON
 
-        self.blackbird.zones[3].power = False
+    mock_blackbird.zones[3].power = False
-        self.media_player.update()
+    await hass.async_add_executor_job(media_player_entity.update)
-        assert self.media_player.state == STATE_OFF
+    assert media_player_entity.state == STATE_OFF
 
-    def test_supported_features(self):
+
+async def test_supported_features(media_player_entity):
     """Test supported features property."""
     assert (
         SUPPORT_TURN_ON | SUPPORT_TURN_OFF | SUPPORT_SELECT_SOURCE
-            == self.media_player.supported_features
+        == media_player_entity.supported_features
     )
 
-    def test_source(self):
+
+async def test_source(hass, media_player_entity):
     """Test source property."""
-        assert self.media_player.source is None
+    assert media_player_entity.source is None
-        self.media_player.update()
+    await hass.async_add_executor_job(media_player_entity.update)
-        assert self.media_player.source == "one"
+    assert media_player_entity.source == "one"
 
-    def test_media_title(self):
+
+async def test_media_title(hass, media_player_entity):
     """Test media title property."""
-        assert self.media_player.media_title is None
+    assert media_player_entity.media_title is None
-        self.media_player.update()
+    await hass.async_add_executor_job(media_player_entity.update)
-        assert self.media_player.media_title == "one"
+    assert media_player_entity.media_title == "one"
 
-    def test_source_list(self):
+
+async def test_source_list(media_player_entity):
     """Test source list property."""
     # Note, the list is sorted!
-        assert self.media_player.source_list == ["one", "two", "three"]
+    assert media_player_entity.source_list == ["one", "two", "three"]
 
-    def test_select_source(self):
+
+async def test_select_source(hass, media_player_entity, mock_blackbird):
     """Test source selection methods."""
-        self.media_player.update()
+    await hass.async_add_executor_job(media_player_entity.update)
 
-        assert self.media_player.source == "one"
+    assert media_player_entity.source == "one"
 
-        self.media_player.select_source("two")
+    await media_player_entity.async_select_source("two")
-        assert self.blackbird.zones[3].av == 2
+    assert mock_blackbird.zones[3].av == 2
-        self.media_player.update()
+    await hass.async_add_executor_job(media_player_entity.update)
-        assert self.media_player.source == "two"
+    assert media_player_entity.source == "two"
 
     # Trying to set unknown source.
-        self.media_player.select_source("no name")
+    await media_player_entity.async_select_source("no name")
-        assert self.blackbird.zones[3].av == 2
+    assert mock_blackbird.zones[3].av == 2
-        self.media_player.update()
+    await hass.async_add_executor_job(media_player_entity.update)
-        assert self.media_player.source == "two"
+    assert media_player_entity.source == "two"
 
-    def test_turn_on(self):
+
+async def test_turn_on(hass, media_player_entity, mock_blackbird):
     """Testing turning on the zone."""
-        self.blackbird.zones[3].power = False
+    mock_blackbird.zones[3].power = False
-        self.media_player.update()
+    await hass.async_add_executor_job(media_player_entity.update)
-        assert self.media_player.state == STATE_OFF
+    assert media_player_entity.state == STATE_OFF
 
-        self.media_player.turn_on()
+    await media_player_entity.async_turn_on()
-        assert self.blackbird.zones[3].power
+    assert mock_blackbird.zones[3].power
-        self.media_player.update()
+    await hass.async_add_executor_job(media_player_entity.update)
-        assert self.media_player.state == STATE_ON
+    assert media_player_entity.state == STATE_ON
 
-    def test_turn_off(self):
+
+async def test_turn_off(hass, media_player_entity, mock_blackbird):
     """Testing turning off the zone."""
-        self.blackbird.zones[3].power = True
+    mock_blackbird.zones[3].power = True
-        self.media_player.update()
+    await hass.async_add_executor_job(media_player_entity.update)
-        assert self.media_player.state == STATE_ON
+    assert media_player_entity.state == STATE_ON
 
-        self.media_player.turn_off()
+    await media_player_entity.async_turn_off()
-        assert not self.blackbird.zones[3].power
+    assert not mock_blackbird.zones[3].power
-        self.media_player.update()
+    await hass.async_add_executor_job(media_player_entity.update)
-        assert self.media_player.state == STATE_OFF
+    assert media_player_entity.state == STATE_OFF