Rewrite vultr unittest to pytest (#63367)

* Rewrite vultr unittest to pytest

* Fix tests

* Fix annotations

* Don't check setup_platform return value

Co-authored-by: epenet <epenet@users.noreply.github.com>

tests/components/vultr/conftest.py

@@ -0,0 +1,30 @@
+"""Test configuration for the Vultr tests."""
+import json
+from unittest.mock import patch
+
+import pytest
+
+from homeassistant.components import vultr
+from homeassistant.core import HomeAssistant
+
+from .const import VALID_CONFIG
+
+from tests.common import load_fixture
+
+
+@pytest.fixture(name="valid_config")
+def valid_config(hass: HomeAssistant, requests_mock):
+    """Load a valid config."""
+    requests_mock.get(
+        "https://api.vultr.com/v1/account/info?api_key=ABCDEFG1234567",
+        text=load_fixture("account_info.json", "vultr"),
+    )
+
+    with patch(
+        "vultr.Vultr.server_list",
+        return_value=json.loads(load_fixture("server_list.json", "vultr")),
+    ):
+        # Setup hub
+        vultr.setup(hass, VALID_CONFIG)
+
+    yield

tests/components/vultr/const.py

@@ -0,0 +1,3 @@
+"""Constants for the Vultr tests."""
+
+VALID_CONFIG = {"vultr": {"api_key": "ABCDEFG1234567"}}

tests/components/vultr/test_binary_sensor.py

@@ -1,10 +1,5 @@
 """Test the Vultr binary sensor platform."""
-import json
-import unittest
-from unittest.mock import patch
-
 import pytest
-import requests_mock
 import voluptuous as vol
 
 from homeassistant.components import vultr as base_vultr
@@ -19,125 +14,91 @@ from homeassistant.components.vultr import (
     binary_sensor as vultr,
 )
 from homeassistant.const import CONF_NAME, CONF_PLATFORM
+from homeassistant.core import HomeAssistant
 
-from tests.common import get_test_home_assistant, load_fixture
+CONFIGS = [
-from tests.components.vultr.test_init import VALID_CONFIG
+    {CONF_SUBSCRIPTION: "576965", CONF_NAME: "A Server"},
+    {CONF_SUBSCRIPTION: "123456", CONF_NAME: "Failed Server"},
+    {CONF_SUBSCRIPTION: "555555", CONF_NAME: vultr.DEFAULT_NAME},
+]
 
 
-class TestVultrBinarySensorSetup(unittest.TestCase):
+@pytest.mark.usefixtures("valid_config")
-    """Test the Vultr binary sensor platform."""
+def test_binary_sensor(hass: HomeAssistant):
+    """Test successful instance."""
+    hass_devices = []
 
-    DEVICES = []
+    def add_entities(devices, action):
-
-    def add_entities(self, devices, action):
         """Mock add devices."""
         for device in devices:
-            self.DEVICES.append(device)
+            device.hass = hass
+            hass_devices.append(device)
 
-    def setUp(self):
+    # Setup each of our test configs
-        """Init values for this testcase class."""
+    for config in CONFIGS:
-        self.hass = get_test_home_assistant()
+        vultr.setup_platform(hass, config, add_entities, None)
-        self.configs = [
-            {CONF_SUBSCRIPTION: "576965", CONF_NAME: "A Server"},
-            {CONF_SUBSCRIPTION: "123456", CONF_NAME: "Failed Server"},
-            {CONF_SUBSCRIPTION: "555555", CONF_NAME: vultr.DEFAULT_NAME},
-        ]
-        self.addCleanup(self.tear_down_cleanup)
 
-    def tear_down_cleanup(self):
+    assert len(hass_devices) == 3
-        """Stop our started services."""
-        self.hass.stop()
 
-    @requests_mock.Mocker()
+    for device in hass_devices:
-    def test_binary_sensor(self, mock):
-        """Test successful instance."""
-        mock.get(
-            "https://api.vultr.com/v1/account/info?api_key=ABCDEFG1234567",
-            text=load_fixture("account_info.json", "vultr"),
-        )
 
-        with patch(
+        # Test pre data retrieval
-            "vultr.Vultr.server_list",
+        if device.subscription == "555555":
-            return_value=json.loads(load_fixture("server_list.json", "vultr")),
+            assert device.name == "Vultr {}"
-        ):
-            # Setup hub
-            base_vultr.setup(self.hass, VALID_CONFIG)
 
-        # Setup each of our test configs
+        device.update()
-        for config in self.configs:
+        device_attrs = device.extra_state_attributes
-            vultr.setup_platform(self.hass, config, self.add_entities, None)
 
-        assert len(self.DEVICES) == 3
+        if device.subscription == "555555":
+            assert device.name == "Vultr Another Server"
 
-        for device in self.DEVICES:
+        if device.name == "A Server":
+            assert device.is_on is True
+            assert device.device_class == "power"
+            assert device.state == "on"
+            assert device.icon == "mdi:server"
+            assert device_attrs[ATTR_ALLOWED_BANDWIDTH] == "1000"
+            assert device_attrs[ATTR_AUTO_BACKUPS] == "yes"
+            assert device_attrs[ATTR_IPV4_ADDRESS] == "123.123.123.123"
+            assert device_attrs[ATTR_COST_PER_MONTH] == "10.05"
+            assert device_attrs[ATTR_CREATED_AT] == "2013-12-19 14:45:41"
+            assert device_attrs[ATTR_SUBSCRIPTION_ID] == "576965"
+        elif device.name == "Failed Server":
+            assert device.is_on is False
+            assert device.state == "off"
+            assert device.icon == "mdi:server-off"
+            assert device_attrs[ATTR_ALLOWED_BANDWIDTH] == "1000"
+            assert device_attrs[ATTR_AUTO_BACKUPS] == "no"
+            assert device_attrs[ATTR_IPV4_ADDRESS] == "192.168.100.50"
+            assert device_attrs[ATTR_COST_PER_MONTH] == "73.25"
+            assert device_attrs[ATTR_CREATED_AT] == "2014-10-13 14:45:41"
+            assert device_attrs[ATTR_SUBSCRIPTION_ID] == "123456"
 
-            # Test pre data retrieval
-            if device.subscription == "555555":
-                assert device.name == "Vultr {}"
 
-            device.update()
+def test_invalid_sensor_config():
-            device_attrs = device.extra_state_attributes
+    """Test config type failures."""
+    with pytest.raises(vol.Invalid):  # No subs
+        vultr.PLATFORM_SCHEMA({CONF_PLATFORM: base_vultr.DOMAIN})
 
-            if device.subscription == "555555":
-                assert device.name == "Vultr Another Server"
 
-            if device.name == "A Server":
+@pytest.mark.usefixtures("valid_config")
-                assert device.is_on is True
+def test_invalid_sensors(hass: HomeAssistant):
-                assert device.device_class == "power"
+    """Test the VultrBinarySensor fails."""
-                assert device.state == "on"
+    hass_devices = []
-                assert device.icon == "mdi:server"
-                assert device_attrs[ATTR_ALLOWED_BANDWIDTH] == "1000"
-                assert device_attrs[ATTR_AUTO_BACKUPS] == "yes"
-                assert device_attrs[ATTR_IPV4_ADDRESS] == "123.123.123.123"
-                assert device_attrs[ATTR_COST_PER_MONTH] == "10.05"
-                assert device_attrs[ATTR_CREATED_AT] == "2013-12-19 14:45:41"
-                assert device_attrs[ATTR_SUBSCRIPTION_ID] == "576965"
-            elif device.name == "Failed Server":
-                assert device.is_on is False
-                assert device.state == "off"
-                assert device.icon == "mdi:server-off"
-                assert device_attrs[ATTR_ALLOWED_BANDWIDTH] == "1000"
-                assert device_attrs[ATTR_AUTO_BACKUPS] == "no"
-                assert device_attrs[ATTR_IPV4_ADDRESS] == "192.168.100.50"
-                assert device_attrs[ATTR_COST_PER_MONTH] == "73.25"
-                assert device_attrs[ATTR_CREATED_AT] == "2014-10-13 14:45:41"
-                assert device_attrs[ATTR_SUBSCRIPTION_ID] == "123456"
 
-    def test_invalid_sensor_config(self):
+    def add_entities(devices, action):
-        """Test config type failures."""
+        """Mock add devices."""
-        with pytest.raises(vol.Invalid):  # No subs
+        for device in devices:
-            vultr.PLATFORM_SCHEMA({CONF_PLATFORM: base_vultr.DOMAIN})
+            device.hass = hass
+            hass_devices.append(device)
 
-    @requests_mock.Mocker()
+    bad_conf = {}  # No subscription
-    def test_invalid_sensors(self, mock):
-        """Test the VultrBinarySensor fails."""
-        mock.get(
-            "https://api.vultr.com/v1/account/info?api_key=ABCDEFG1234567",
-            text=load_fixture("account_info.json", "vultr"),
-        )
 
-        with patch(
+    vultr.setup_platform(hass, bad_conf, add_entities, None)
-            "vultr.Vultr.server_list",
-            return_value=json.loads(load_fixture("server_list.json", "vultr")),
-        ):
-            # Setup hub
-            base_vultr.setup(self.hass, VALID_CONFIG)
 
-        bad_conf = {}  # No subscription
+    bad_conf = {
+        CONF_NAME: "Missing Server",
+        CONF_SUBSCRIPTION: "555555",
+    }  # Sub not associated with API key (not in server_list)
 
-        no_subs_setup = vultr.setup_platform(
+    vultr.setup_platform(hass, bad_conf, add_entities, None)
-            self.hass, bad_conf, self.add_entities, None
-        )
-
-        assert not no_subs_setup
-
-        bad_conf = {
-            CONF_NAME: "Missing Server",
-            CONF_SUBSCRIPTION: "555555",
-        }  # Sub not associated with API key (not in server_list)
-
-        wrong_subs_setup = vultr.setup_platform(
-            self.hass, bad_conf, self.add_entities, None
-        )
-
-        assert not wrong_subs_setup

tests/components/vultr/test_init.py

@@ -1,44 +1,29 @@
 """The tests for the Vultr component."""
 from copy import deepcopy
 import json
-import unittest
 from unittest.mock import patch
 
-import requests_mock
-
 from homeassistant import setup
-import homeassistant.components.vultr as vultr
+from homeassistant.components import vultr
+from homeassistant.core import HomeAssistant
 
-from tests.common import get_test_home_assistant, load_fixture
+from .const import VALID_CONFIG
 
-VALID_CONFIG = {"vultr": {"api_key": "ABCDEFG1234567"}}
+from tests.common import load_fixture
 
 
-class TestVultr(unittest.TestCase):
+def test_setup(hass: HomeAssistant):
-    """Tests the Vultr component."""
+    """Test successful setup."""
+    with patch(
+        "vultr.Vultr.server_list",
+        return_value=json.loads(load_fixture("server_list.json", "vultr")),
+    ):
+        response = vultr.setup(hass, VALID_CONFIG)
+    assert response
 
-    def setUp(self):
-        """Initialize values for this test case class."""
-        self.hass = get_test_home_assistant()
-        self.config = VALID_CONFIG
-        self.addCleanup(self.tear_down_cleanup)
 
-    def tear_down_cleanup(self):
+async def test_setup_no_api_key(hass: HomeAssistant):
-        """Stop everything that we started."""
+    """Test failed setup with missing API Key."""
-        self.hass.stop()
+    conf = deepcopy(VALID_CONFIG)
-
+    del conf["vultr"]["api_key"]
-    @requests_mock.Mocker()
+    assert not await setup.async_setup_component(hass, vultr.DOMAIN, conf)
-    def test_setup(self, mock):
-        """Test successful setup."""
-        with patch(
-            "vultr.Vultr.server_list",
-            return_value=json.loads(load_fixture("server_list.json", "vultr")),
-        ):
-            response = vultr.setup(self.hass, self.config)
-        assert response
-
-    def test_setup_no_api_key(self):
-        """Test failed setup with missing API Key."""
-        conf = deepcopy(self.config)
-        del conf["vultr"]["api_key"]
-        assert not setup.setup_component(self.hass, vultr.DOMAIN, conf)

tests/components/vultr/test_sensor.py

@@ -1,10 +1,5 @@
 """The tests for the Vultr sensor platform."""
-import json
-import unittest
-from unittest.mock import patch
-
 import pytest
-import requests_mock
 import voluptuous as vol
 
 from homeassistant.components import vultr as base_vultr
@@ -16,152 +11,124 @@ from homeassistant.const import (
     CONF_PLATFORM,
     DATA_GIGABYTES,
 )
+from homeassistant.core import HomeAssistant
 
-from tests.common import get_test_home_assistant, load_fixture
+CONFIGS = [
-from tests.components.vultr.test_init import VALID_CONFIG
+    {
+        CONF_NAME: vultr.DEFAULT_NAME,
+        CONF_SUBSCRIPTION: "576965",
+        CONF_MONITORED_CONDITIONS: vultr.SENSOR_KEYS,
+    },
+    {
+        CONF_NAME: "Server {}",
+        CONF_SUBSCRIPTION: "123456",
+        CONF_MONITORED_CONDITIONS: vultr.SENSOR_KEYS,
+    },
+    {
+        CONF_NAME: "VPS Charges",
+        CONF_SUBSCRIPTION: "555555",
+        CONF_MONITORED_CONDITIONS: ["pending_charges"],
+    },
+]
 
 
-class TestVultrSensorSetup(unittest.TestCase):
+@pytest.mark.usefixtures("valid_config")
-    """Test the Vultr platform."""
+def test_sensor(hass: HomeAssistant):
+    """Test the Vultr sensor class and methods."""
+    hass_devices = []
 
-    DEVICES = []
+    def add_entities(devices, action):
-
-    def add_entities(self, devices, action):
         """Mock add devices."""
         for device in devices:
-            device.hass = self.hass
+            device.hass = hass
-            self.DEVICES.append(device)
+            hass_devices.append(device)
 
-    def setUp(self):
+    for config in CONFIGS:
-        """Initialize values for this testcase class."""
+        vultr.setup_platform(hass, config, add_entities, None)
-        self.hass = get_test_home_assistant()
-        self.configs = [
-            {
-                CONF_NAME: vultr.DEFAULT_NAME,
-                CONF_SUBSCRIPTION: "576965",
-                CONF_MONITORED_CONDITIONS: vultr.SENSOR_KEYS,
-            },
-            {
-                CONF_NAME: "Server {}",
-                CONF_SUBSCRIPTION: "123456",
-                CONF_MONITORED_CONDITIONS: vultr.SENSOR_KEYS,
-            },
-            {
-                CONF_NAME: "VPS Charges",
-                CONF_SUBSCRIPTION: "555555",
-                CONF_MONITORED_CONDITIONS: ["pending_charges"],
-            },
-        ]
-        self.addCleanup(self.hass.stop)
 
-    @requests_mock.Mocker()
+    assert len(hass_devices) == 5
-    def test_sensor(self, mock):
-        """Test the Vultr sensor class and methods."""
-        mock.get(
-            "https://api.vultr.com/v1/account/info?api_key=ABCDEFG1234567",
-            text=load_fixture("account_info.json", "vultr"),
-        )
 
-        with patch(
+    tested = 0
-            "vultr.Vultr.server_list",
-            return_value=json.loads(load_fixture("server_list.json", "vultr")),
-        ):
-            # Setup hub
-            base_vultr.setup(self.hass, VALID_CONFIG)
 
-        for config in self.configs:
+    for device in hass_devices:
-            setup = vultr.setup_platform(self.hass, config, self.add_entities, None)
 
-            assert setup is None
+        # Test pre update
+        if device.subscription == "576965":
+            assert vultr.DEFAULT_NAME == device.name
 
-        assert len(self.DEVICES) == 5
+        device.update()
 
-        tested = 0
+        if device.unit_of_measurement == DATA_GIGABYTES:  # Test Bandwidth Used
-
-        for device in self.DEVICES:
-
-            # Test pre update
             if device.subscription == "576965":
-                assert vultr.DEFAULT_NAME == device.name
+                assert device.name == "Vultr my new server Current Bandwidth Used"
+                assert device.icon == "mdi:chart-histogram"
+                assert device.state == 131.51
+                assert device.icon == "mdi:chart-histogram"
+                tested += 1
 
-            device.update()
+            elif device.subscription == "123456":
+                assert device.name == "Server Current Bandwidth Used"
+                assert device.state == 957.46
+                tested += 1
 
-            if device.unit_of_measurement == DATA_GIGABYTES:  # Test Bandwidth Used
+        elif device.unit_of_measurement == "US$":  # Test Pending Charges
-                if device.subscription == "576965":
-                    assert device.name == "Vultr my new server Current Bandwidth Used"
-                    assert device.icon == "mdi:chart-histogram"
-                    assert device.state == 131.51
-                    assert device.icon == "mdi:chart-histogram"
-                    tested += 1
 
-                elif device.subscription == "123456":
+            if device.subscription == "576965":  # Default 'Vultr {} {}'
-                    assert device.name == "Server Current Bandwidth Used"
+                assert device.name == "Vultr my new server Pending Charges"
-                    assert device.state == 957.46
+                assert device.icon == "mdi:currency-usd"
-                    tested += 1
+                assert device.state == 46.67
+                assert device.icon == "mdi:currency-usd"
+                tested += 1
 
-            elif device.unit_of_measurement == "US$":  # Test Pending Charges
+            elif device.subscription == "123456":  # Custom name with 1 {}
+                assert device.name == "Server Pending Charges"
+                assert device.state == "not a number"
+                tested += 1
 
-                if device.subscription == "576965":  # Default 'Vultr {} {}'
+            elif device.subscription == "555555":  # No {} in name
-                    assert device.name == "Vultr my new server Pending Charges"
+                assert device.name == "VPS Charges"
-                    assert device.icon == "mdi:currency-usd"
+                assert device.state == 5.45
-                    assert device.state == 46.67
+                tested += 1
-                    assert device.icon == "mdi:currency-usd"
-                    tested += 1
 
-                elif device.subscription == "123456":  # Custom name with 1 {}
+    assert tested == 5
-                    assert device.name == "Server Pending Charges"
-                    assert device.state == "not a number"
-                    tested += 1
 
-                elif device.subscription == "555555":  # No {} in name
-                    assert device.name == "VPS Charges"
-                    assert device.state == 5.45
-                    tested += 1
 
-        assert tested == 5
+def test_invalid_sensor_config():
-
+    """Test config type failures."""
-    def test_invalid_sensor_config(self):
+    with pytest.raises(vol.Invalid):  # No subscription
-        """Test config type failures."""
+        vultr.PLATFORM_SCHEMA(
-        with pytest.raises(vol.Invalid):  # No subscription
+            {
-            vultr.PLATFORM_SCHEMA(
+                CONF_PLATFORM: base_vultr.DOMAIN,
-                {
+                CONF_MONITORED_CONDITIONS: vultr.SENSOR_KEYS,
-                    CONF_PLATFORM: base_vultr.DOMAIN,
+            }
-                    CONF_MONITORED_CONDITIONS: vultr.SENSOR_KEYS,
+        )
-                }
+    with pytest.raises(vol.Invalid):  # Bad monitored_conditions
-            )
+        vultr.PLATFORM_SCHEMA(
-        with pytest.raises(vol.Invalid):  # Bad monitored_conditions
+            {
-            vultr.PLATFORM_SCHEMA(
+                CONF_PLATFORM: base_vultr.DOMAIN,
-                {
+                CONF_SUBSCRIPTION: "123456",
-                    CONF_PLATFORM: base_vultr.DOMAIN,
+                CONF_MONITORED_CONDITIONS: ["non-existent-condition"],
-                    CONF_SUBSCRIPTION: "123456",
+            }
-                    CONF_MONITORED_CONDITIONS: ["non-existent-condition"],
-                }
-            )
-
-    @requests_mock.Mocker()
-    def test_invalid_sensors(self, mock):
-        """Test the VultrSensor fails."""
-        mock.get(
-            "https://api.vultr.com/v1/account/info?api_key=ABCDEFG1234567",
-            text=load_fixture("account_info.json", "vultr"),
         )
 
-        with patch(
-            "vultr.Vultr.server_list",
-            return_value=json.loads(load_fixture("server_list.json", "vultr")),
-        ):
-            # Setup hub
-            base_vultr.setup(self.hass, VALID_CONFIG)
 
-        bad_conf = {
+@pytest.mark.usefixtures("valid_config")
-            CONF_NAME: "Vultr {} {}",
+def test_invalid_sensors(hass: HomeAssistant):
-            CONF_SUBSCRIPTION: "",
+    """Test the VultrSensor fails."""
-            CONF_MONITORED_CONDITIONS: vultr.SENSOR_KEYS,
+    hass_devices = []
-        }  # No subs at all
 
-        no_sub_setup = vultr.setup_platform(
+    def add_entities(devices, action):
-            self.hass, bad_conf, self.add_entities, None
+        """Mock add devices."""
-        )
+        for device in devices:
+            device.hass = hass
+            hass_devices.append(device)
 
-        assert no_sub_setup is None
+    bad_conf = {
-        assert len(self.DEVICES) == 0
+        CONF_NAME: "Vultr {} {}",
+        CONF_SUBSCRIPTION: "",
+        CONF_MONITORED_CONDITIONS: vultr.SENSOR_KEYS,
+    }  # No subs at all
+
+    vultr.setup_platform(hass, bad_conf, add_entities, None)
+
+    assert len(hass_devices) == 0

tests/components/vultr/test_switch.py

@@ -1,10 +1,10 @@
 """Test the Vultr switch platform."""
+from __future__ import annotations
+
 import json
-import unittest
 from unittest.mock import patch
 
 import pytest
-import requests_mock
 import voluptuous as vol
 
 from homeassistant.components import vultr as base_vultr
@@ -19,159 +19,137 @@ from homeassistant.components.vultr import (
     switch as vultr,
 )
 from homeassistant.const import CONF_NAME, CONF_PLATFORM
+from homeassistant.core import HomeAssistant
 
-from tests.common import get_test_home_assistant, load_fixture
+from tests.common import load_fixture
-from tests.components.vultr.test_init import VALID_CONFIG
+
+CONFIGS = [
+    {CONF_SUBSCRIPTION: "576965", CONF_NAME: "A Server"},
+    {CONF_SUBSCRIPTION: "123456", CONF_NAME: "Failed Server"},
+    {CONF_SUBSCRIPTION: "555555", CONF_NAME: vultr.DEFAULT_NAME},
+]
 
 
-class TestVultrSwitchSetup(unittest.TestCase):
+@pytest.fixture(name="hass_devices")
-    """Test the Vultr switch platform."""
+def load_hass_devices(hass: HomeAssistant):
+    """Load a valid config."""
+    hass_devices = []
 
-    DEVICES = []
+    def add_entities(devices, action):
-
-    def add_entities(self, devices, action):
         """Mock add devices."""
         for device in devices:
-            self.DEVICES.append(device)
+            device.hass = hass
+            hass_devices.append(device)
 
-    def setUp(self):
+    # Setup each of our test configs
-        """Init values for this testcase class."""
+    for config in CONFIGS:
-        self.hass = get_test_home_assistant()
+        vultr.setup_platform(hass, config, add_entities, None)
-        self.configs = [
-            {CONF_SUBSCRIPTION: "576965", CONF_NAME: "A Server"},
-            {CONF_SUBSCRIPTION: "123456", CONF_NAME: "Failed Server"},
-            {CONF_SUBSCRIPTION: "555555", CONF_NAME: vultr.DEFAULT_NAME},
-        ]
-        self.addCleanup(self.tear_down_cleanup)
 
-    def tear_down_cleanup(self):
+    yield hass_devices
-        """Stop our started services."""
-        self.hass.stop()
 
-    @requests_mock.Mocker()
-    def test_switch(self, mock):
-        """Test successful instance."""
-        mock.get(
-            "https://api.vultr.com/v1/account/info?api_key=ABCDEFG1234567",
-            text=load_fixture("account_info.json", "vultr"),
-        )
 
-        with patch(
+@pytest.mark.usefixtures("valid_config")
-            "vultr.Vultr.server_list",
+def test_switch(hass: HomeAssistant, hass_devices: list[vultr.VultrSwitch]):
-            return_value=json.loads(load_fixture("server_list.json", "vultr")),
+    """Test successful instance."""
-        ):
-            # Setup hub
-            base_vultr.setup(self.hass, VALID_CONFIG)
 
-        # Setup each of our test configs
+    assert len(hass_devices) == 3
-        for config in self.configs:
-            vultr.setup_platform(self.hass, config, self.add_entities, None)
 
-        assert len(self.DEVICES) == 3
+    tested = 0
 
-        tested = 0
+    for device in hass_devices:
+        if device.subscription == "555555":
+            assert device.name == "Vultr {}"
+            tested += 1
 
-        for device in self.DEVICES:
+        device.update()
-            if device.subscription == "555555":
+        device_attrs = device.extra_state_attributes
-                assert device.name == "Vultr {}"
-                tested += 1
 
-            device.update()
+        if device.subscription == "555555":
-            device_attrs = device.extra_state_attributes
+            assert device.name == "Vultr Another Server"
+            tested += 1
 
-            if device.subscription == "555555":
+        if device.name == "A Server":
-                assert device.name == "Vultr Another Server"
+            assert device.is_on is True
-                tested += 1
+            assert device.state == "on"
+            assert device.icon == "mdi:server"
+            assert device_attrs[ATTR_ALLOWED_BANDWIDTH] == "1000"
+            assert device_attrs[ATTR_AUTO_BACKUPS] == "yes"
+            assert device_attrs[ATTR_IPV4_ADDRESS] == "123.123.123.123"
+            assert device_attrs[ATTR_COST_PER_MONTH] == "10.05"
+            assert device_attrs[ATTR_CREATED_AT] == "2013-12-19 14:45:41"
+            assert device_attrs[ATTR_SUBSCRIPTION_ID] == "576965"
+            tested += 1
 
+        elif device.name == "Failed Server":
+            assert device.is_on is False
+            assert device.state == "off"
+            assert device.icon == "mdi:server-off"
+            assert device_attrs[ATTR_ALLOWED_BANDWIDTH] == "1000"
+            assert device_attrs[ATTR_AUTO_BACKUPS] == "no"
+            assert device_attrs[ATTR_IPV4_ADDRESS] == "192.168.100.50"
+            assert device_attrs[ATTR_COST_PER_MONTH] == "73.25"
+            assert device_attrs[ATTR_CREATED_AT] == "2014-10-13 14:45:41"
+            assert device_attrs[ATTR_SUBSCRIPTION_ID] == "123456"
+            tested += 1
+
+    assert tested == 4
+
+
+@pytest.mark.usefixtures("valid_config")
+def test_turn_on(hass: HomeAssistant, hass_devices: list[vultr.VultrSwitch]):
+    """Test turning a subscription on."""
+    with patch(
+        "vultr.Vultr.server_list",
+        return_value=json.loads(load_fixture("server_list.json", "vultr")),
+    ), patch("vultr.Vultr.server_start") as mock_start:
+        for device in hass_devices:
+            if device.name == "Failed Server":
+                device.update()
+                device.turn_on()
+
+    # Turn on
+    assert mock_start.call_count == 1
+
+
+@pytest.mark.usefixtures("valid_config")
+def test_turn_off(hass: HomeAssistant, hass_devices: list[vultr.VultrSwitch]):
+    """Test turning a subscription off."""
+    with patch(
+        "vultr.Vultr.server_list",
+        return_value=json.loads(load_fixture("server_list.json", "vultr")),
+    ), patch("vultr.Vultr.server_halt") as mock_halt:
+        for device in hass_devices:
             if device.name == "A Server":
-                assert device.is_on is True
+                device.update()
-                assert device.state == "on"
+                device.turn_off()
-                assert device.icon == "mdi:server"
-                assert device_attrs[ATTR_ALLOWED_BANDWIDTH] == "1000"
-                assert device_attrs[ATTR_AUTO_BACKUPS] == "yes"
-                assert device_attrs[ATTR_IPV4_ADDRESS] == "123.123.123.123"
-                assert device_attrs[ATTR_COST_PER_MONTH] == "10.05"
-                assert device_attrs[ATTR_CREATED_AT] == "2013-12-19 14:45:41"
-                assert device_attrs[ATTR_SUBSCRIPTION_ID] == "576965"
-                tested += 1
 
-            elif device.name == "Failed Server":
+    # Turn off
-                assert device.is_on is False
+    assert mock_halt.call_count == 1
-                assert device.state == "off"
-                assert device.icon == "mdi:server-off"
-                assert device_attrs[ATTR_ALLOWED_BANDWIDTH] == "1000"
-                assert device_attrs[ATTR_AUTO_BACKUPS] == "no"
-                assert device_attrs[ATTR_IPV4_ADDRESS] == "192.168.100.50"
-                assert device_attrs[ATTR_COST_PER_MONTH] == "73.25"
-                assert device_attrs[ATTR_CREATED_AT] == "2014-10-13 14:45:41"
-                assert device_attrs[ATTR_SUBSCRIPTION_ID] == "123456"
-                tested += 1
 
-        assert tested == 4
 
-    @requests_mock.Mocker()
+def test_invalid_switch_config():
-    def test_turn_on(self, mock):
+    """Test config type failures."""
-        """Test turning a subscription on."""
+    with pytest.raises(vol.Invalid):  # No subscription
-        with patch(
+        vultr.PLATFORM_SCHEMA({CONF_PLATFORM: base_vultr.DOMAIN})
-            "vultr.Vultr.server_list",
-            return_value=json.loads(load_fixture("server_list.json", "vultr")),
-        ), patch("vultr.Vultr.server_start") as mock_start:
-            for device in self.DEVICES:
-                if device.name == "Failed Server":
-                    device.turn_on()
 
-        # Turn on
-        assert mock_start.call_count == 1
 
-    @requests_mock.Mocker()
+@pytest.mark.usefixtures("valid_config")
-    def test_turn_off(self, mock):
+def test_invalid_switches(hass: HomeAssistant):
-        """Test turning a subscription off."""
+    """Test the VultrSwitch fails."""
-        with patch(
+    hass_devices = []
-            "vultr.Vultr.server_list",
-            return_value=json.loads(load_fixture("server_list.json", "vultr")),
-        ), patch("vultr.Vultr.server_halt") as mock_halt:
-            for device in self.DEVICES:
-                if device.name == "A Server":
-                    device.turn_off()
 
-        # Turn off
+    def add_entities(devices, action):
-        assert mock_halt.call_count == 1
+        """Mock add devices."""
+        for device in devices:
+            hass_devices.append(device)
 
-    def test_invalid_switch_config(self):
+    bad_conf = {}  # No subscription
-        """Test config type failures."""
-        with pytest.raises(vol.Invalid):  # No subscription
-            vultr.PLATFORM_SCHEMA({CONF_PLATFORM: base_vultr.DOMAIN})
 
-    @requests_mock.Mocker()
+    vultr.setup_platform(hass, bad_conf, add_entities, None)
-    def test_invalid_switches(self, mock):
-        """Test the VultrSwitch fails."""
-        mock.get(
-            "https://api.vultr.com/v1/account/info?api_key=ABCDEFG1234567",
-            text=load_fixture("account_info.json", "vultr"),
-        )
 
-        with patch(
+    bad_conf = {
-            "vultr.Vultr.server_list",
+        CONF_NAME: "Missing Server",
-            return_value=json.loads(load_fixture("server_list.json", "vultr")),
+        CONF_SUBSCRIPTION: "665544",
-        ):
+    }  # Sub not associated with API key (not in server_list)
-            # Setup hub
-            base_vultr.setup(self.hass, VALID_CONFIG)
 
-        bad_conf = {}  # No subscription
+    vultr.setup_platform(hass, bad_conf, add_entities, None)
-
-        no_subs_setup = vultr.setup_platform(
-            self.hass, bad_conf, self.add_entities, None
-        )
-
-        assert no_subs_setup is not None
-
-        bad_conf = {
-            CONF_NAME: "Missing Server",
-            CONF_SUBSCRIPTION: "665544",
-        }  # Sub not associated with API key (not in server_list)
-
-        wrong_subs_setup = vultr.setup_platform(
-            self.hass, bad_conf, self.add_entities, None
-        )
-
-        assert wrong_subs_setup is not None