Rewrite mfi unittest tests to pytest (#42510)

tests/components/mfi/test_sensor.py

@@ -1,25 +1,19 @@
 """The tests for the mFi sensor platform."""
-import unittest
-
 from mficlient.client import FailedToLogin
+import pytest
 import requests
 
 import homeassistant.components.mfi.sensor as mfi
-import homeassistant.components.sensor as sensor
+import homeassistant.components.sensor as sensor_component
 from homeassistant.const import TEMP_CELSIUS
-from homeassistant.setup import setup_component
+from homeassistant.setup import async_setup_component
 
 import tests.async_mock as mock
-from tests.common import get_test_home_assistant
 
-
+PLATFORM = mfi
-class TestMfiSensorSetup(unittest.TestCase):
+COMPONENT = sensor_component
-    """Test the mFi sensor platform."""
+THING = "sensor"
-
+GOOD_CONFIG = {
-    PLATFORM = mfi
-    COMPONENT = sensor
-    THING = "sensor"
-    GOOD_CONFIG = {
     "sensor": {
         "platform": "mfi",
         "host": "foo",
@@ -29,77 +23,79 @@ class TestMfiSensorSetup(unittest.TestCase):
         "ssl": True,
         "verify_ssl": True,
     }
-    }
+}
 
-    def setup_method(self, method):
-        """Set up things to be run when tests are started."""
-        self.hass = get_test_home_assistant()
 
-    def teardown_method(self, method):
+async def test_setup_missing_config(hass):
-        """Stop everything that was started."""
-        self.hass.stop()
-
-    @mock.patch("homeassistant.components.mfi.sensor.MFiClient")
-    def test_setup_missing_config(self, mock_client):
     """Test setup with missing configuration."""
+    with mock.patch("homeassistant.components.mfi.sensor.MFiClient") as mock_client:
         config = {"sensor": {"platform": "mfi"}}
-        assert setup_component(self.hass, "sensor", config)
+        assert await async_setup_component(hass, "sensor", config)
         assert not mock_client.called
 
-    @mock.patch("homeassistant.components.mfi.sensor.MFiClient")
+
-    def test_setup_failed_login(self, mock_client):
+async def test_setup_failed_login(hass):
     """Test setup with login failure."""
+    with mock.patch("homeassistant.components.mfi.sensor.MFiClient") as mock_client:
         mock_client.side_effect = FailedToLogin
-        assert not self.PLATFORM.setup_platform(self.hass, dict(self.GOOD_CONFIG), None)
+        assert not PLATFORM.setup_platform(hass, dict(GOOD_CONFIG), None)
 
-    @mock.patch("homeassistant.components.mfi.sensor.MFiClient")
+
-    def test_setup_failed_connect(self, mock_client):
+async def test_setup_failed_connect(hass):
     """Test setup with connection failure."""
+    with mock.patch("homeassistant.components.mfi.sensor.MFiClient") as mock_client:
         mock_client.side_effect = requests.exceptions.ConnectionError
-        assert not self.PLATFORM.setup_platform(self.hass, dict(self.GOOD_CONFIG), None)
+        assert not PLATFORM.setup_platform(hass, dict(GOOD_CONFIG), None)
 
-    @mock.patch("homeassistant.components.mfi.sensor.MFiClient")
+
-    def test_setup_minimum(self, mock_client):
+async def test_setup_minimum(hass):
     """Test setup with minimum configuration."""
-        config = dict(self.GOOD_CONFIG)
+    with mock.patch("homeassistant.components.mfi.sensor.MFiClient") as mock_client:
-        del config[self.THING]["port"]
+        config = dict(GOOD_CONFIG)
-        assert setup_component(self.hass, self.COMPONENT.DOMAIN, config)
+        del config[THING]["port"]
-        self.hass.block_till_done()
+        assert await async_setup_component(hass, COMPONENT.DOMAIN, config)
+        await hass.async_block_till_done()
         assert mock_client.call_count == 1
         assert mock_client.call_args == mock.call(
             "foo", "user", "pass", port=6443, use_tls=True, verify=True
         )
 
-    @mock.patch("homeassistant.components.mfi.sensor.MFiClient")
+
-    def test_setup_with_port(self, mock_client):
+async def test_setup_with_port(hass):
     """Test setup with port."""
-        config = dict(self.GOOD_CONFIG)
+    with mock.patch("homeassistant.components.mfi.sensor.MFiClient") as mock_client:
-        config[self.THING]["port"] = 6123
+        config = dict(GOOD_CONFIG)
-        assert setup_component(self.hass, self.COMPONENT.DOMAIN, config)
+        config[THING]["port"] = 6123
-        self.hass.block_till_done()
+        assert await async_setup_component(hass, COMPONENT.DOMAIN, config)
+        await hass.async_block_till_done()
         assert mock_client.call_count == 1
         assert mock_client.call_args == mock.call(
             "foo", "user", "pass", port=6123, use_tls=True, verify=True
         )
 
-    @mock.patch("homeassistant.components.mfi.sensor.MFiClient")
+
-    def test_setup_with_tls_disabled(self, mock_client):
+async def test_setup_with_tls_disabled(hass):
     """Test setup without TLS."""
-        config = dict(self.GOOD_CONFIG)
+    with mock.patch("homeassistant.components.mfi.sensor.MFiClient") as mock_client:
-        del config[self.THING]["port"]
+        config = dict(GOOD_CONFIG)
-        config[self.THING]["ssl"] = False
+        del config[THING]["port"]
-        config[self.THING]["verify_ssl"] = False
+        config[THING]["ssl"] = False
-        assert setup_component(self.hass, self.COMPONENT.DOMAIN, config)
+        config[THING]["verify_ssl"] = False
-        self.hass.block_till_done()
+        assert await async_setup_component(hass, COMPONENT.DOMAIN, config)
+        await hass.async_block_till_done()
         assert mock_client.call_count == 1
         assert mock_client.call_args == mock.call(
             "foo", "user", "pass", port=6080, use_tls=False, verify=False
         )
 
-    @mock.patch("homeassistant.components.mfi.sensor.MFiClient")
+
-    @mock.patch("homeassistant.components.mfi.sensor.MfiSensor")
+async def test_setup_adds_proper_devices(hass):
-    def test_setup_adds_proper_devices(self, mock_sensor, mock_client):
     """Test if setup adds devices."""
+    with mock.patch(
+        "homeassistant.components.mfi.sensor.MFiClient"
+    ) as mock_client, mock.patch(
+        "homeassistant.components.mfi.sensor.MfiSensor"
+    ) as mock_sensor:
         ports = {
             i: mock.MagicMock(model=model) for i, model in enumerate(mfi.SENSOR_MODELS)
         }
@@ -107,82 +103,90 @@ class TestMfiSensorSetup(unittest.TestCase):
         mock_client.return_value.get_devices.return_value = [
             mock.MagicMock(ports=ports)
         ]
-        assert setup_component(self.hass, sensor.DOMAIN, self.GOOD_CONFIG)
+        assert await async_setup_component(hass, COMPONENT.DOMAIN, GOOD_CONFIG)
-        self.hass.block_till_done()
+        await hass.async_block_till_done()
         for ident, port in ports.items():
             if ident != "bad":
-                mock_sensor.assert_any_call(port, self.hass)
+                mock_sensor.assert_any_call(port, hass)
-        assert mock.call(ports["bad"], self.hass) not in mock_sensor.mock_calls
+        assert mock.call(ports["bad"], hass) not in mock_sensor.mock_calls
 
 
-class TestMfiSensor(unittest.TestCase):
+@pytest.fixture(name="port")
-    """Test for mFi sensor platform."""
+def port_fixture():
+    """Port fixture."""
+    return mock.MagicMock()
 
-    def setup_method(self, method):
-        """Set up things to be run when tests are started."""
-        self.hass = get_test_home_assistant()
-        self.port = mock.MagicMock()
-        self.sensor = mfi.MfiSensor(self.port, self.hass)
 
-    def teardown_method(self, method):
+@pytest.fixture(name="sensor")
-        """Stop everything that was started."""
+def sensor_fixture(hass, port):
-        self.hass.stop()
+    """Sensor fixture."""
+    return mfi.MfiSensor(port, hass)
 
-    def test_name(self):
+
+async def test_name(port, sensor):
     """Test the name."""
-        assert self.port.label == self.sensor.name
+    assert port.label == sensor.name
 
-    def test_uom_temp(self):
+
+async def test_uom_temp(port, sensor):
     """Test the UOM temperature."""
-        self.port.tag = "temperature"
+    port.tag = "temperature"
-        assert TEMP_CELSIUS == self.sensor.unit_of_measurement
+    assert TEMP_CELSIUS == sensor.unit_of_measurement
 
-    def test_uom_power(self):
+
+async def test_uom_power(port, sensor):
     """Test the UOEM power."""
-        self.port.tag = "active_pwr"
+    port.tag = "active_pwr"
-        assert "Watts" == self.sensor.unit_of_measurement
+    assert sensor.unit_of_measurement == "Watts"
 
-    def test_uom_digital(self):
+
+async def test_uom_digital(port, sensor):
     """Test the UOM digital input."""
-        self.port.model = "Input Digital"
+    port.model = "Input Digital"
-        assert "State" == self.sensor.unit_of_measurement
+    assert sensor.unit_of_measurement == "State"
 
-    def test_uom_unknown(self):
+
+async def test_uom_unknown(port, sensor):
     """Test the UOM."""
-        self.port.tag = "balloons"
+    port.tag = "balloons"
-        assert "balloons" == self.sensor.unit_of_measurement
+    assert sensor.unit_of_measurement == "balloons"
 
-    def test_uom_uninitialized(self):
+
+async def test_uom_uninitialized(port, sensor):
     """Test that the UOM defaults if not initialized."""
-        type(self.port).tag = mock.PropertyMock(side_effect=ValueError)
+    type(port).tag = mock.PropertyMock(side_effect=ValueError)
-        assert "State" == self.sensor.unit_of_measurement
+    assert sensor.unit_of_measurement == "State"
 
-    def test_state_digital(self):
+
+async def test_state_digital(port, sensor):
     """Test the digital input."""
-        self.port.model = "Input Digital"
+    port.model = "Input Digital"
-        self.port.value = 0
+    port.value = 0
-        assert mfi.STATE_OFF == self.sensor.state
+    assert mfi.STATE_OFF == sensor.state
-        self.port.value = 1
+    port.value = 1
-        assert mfi.STATE_ON == self.sensor.state
+    assert mfi.STATE_ON == sensor.state
-        self.port.value = 2
+    port.value = 2
-        assert mfi.STATE_ON == self.sensor.state
+    assert mfi.STATE_ON == sensor.state
 
-    def test_state_digits(self):
+
+async def test_state_digits(port, sensor):
     """Test the state of digits."""
-        self.port.tag = "didyoucheckthedict?"
+    port.tag = "didyoucheckthedict?"
-        self.port.value = 1.25
+    port.value = 1.25
     with mock.patch.dict(mfi.DIGITS, {"didyoucheckthedict?": 1}):
-            assert 1.2 == self.sensor.state
+        assert sensor.state == 1.2
     with mock.patch.dict(mfi.DIGITS, {}):
-            assert 1.0 == self.sensor.state
+        assert sensor.state == 1.0
 
-    def test_state_uninitialized(self):
-        """Test the state of uninitialized sensors."""
-        type(self.port).tag = mock.PropertyMock(side_effect=ValueError)
-        assert mfi.STATE_OFF == self.sensor.state
 
-    def test_update(self):
+async def test_state_uninitialized(port, sensor):
+    """Test the state of uninitialized sensorfs."""
+    type(port).tag = mock.PropertyMock(side_effect=ValueError)
+    assert mfi.STATE_OFF == sensor.state
+
+
+async def test_update(port, sensor):
     """Test the update."""
-        self.sensor.update()
+    sensor.update()
-        assert self.port.refresh.call_count == 1
+    assert port.refresh.call_count == 1
-        assert self.port.refresh.call_args == mock.call()
+    assert port.refresh.call_args == mock.call()

tests/components/mfi/test_switch.py

@@ -1,21 +1,16 @@
 """The tests for the mFi switch platform."""
-import unittest
+import pytest
 
 import homeassistant.components.mfi.switch as mfi
-import homeassistant.components.switch as switch
+import homeassistant.components.switch as switch_component
-from homeassistant.setup import setup_component
+from homeassistant.setup import async_setup_component
 
 import tests.async_mock as mock
-from tests.common import get_test_home_assistant
 
-
+PLATFORM = mfi
-class TestMfiSwitchSetup(unittest.TestCase):
+COMPONENT = switch_component
-    """Test the mFi switch."""
+THING = "switch"
-
+GOOD_CONFIG = {
-    PLATFORM = mfi
-    COMPONENT = switch
-    THING = "switch"
-    GOOD_CONFIG = {
     "switch": {
         "platform": "mfi",
         "host": "foo",
@@ -25,20 +20,16 @@ class TestMfiSwitchSetup(unittest.TestCase):
         "ssl": True,
         "verify_ssl": True,
     }
-    }
+}
 
-    def setup_method(self, method):
-        """Set up things to be run when tests are started."""
-        self.hass = get_test_home_assistant()
 
-    def teardown_method(self, method):
+async def test_setup_adds_proper_devices(hass):
-        """Stop everything that was started."""
-        self.hass.stop()
-
-    @mock.patch("homeassistant.components.mfi.switch.MFiClient")
-    @mock.patch("homeassistant.components.mfi.switch.MfiSwitch")
-    def test_setup_adds_proper_devices(self, mock_switch, mock_client):
     """Test if setup adds devices."""
+    with mock.patch(
+        "homeassistant.components.mfi.switch.MFiClient"
+    ) as mock_client, mock.patch(
+        "homeassistant.components.mfi.switch.MfiSwitch"
+    ) as mock_switch:
         ports = {
             i: mock.MagicMock(model=model) for i, model in enumerate(mfi.SWITCH_MODELS)
         }
@@ -47,74 +38,84 @@ class TestMfiSwitchSetup(unittest.TestCase):
         mock_client.return_value.get_devices.return_value = [
             mock.MagicMock(ports=ports)
         ]
-        assert setup_component(self.hass, switch.DOMAIN, self.GOOD_CONFIG)
+        assert await async_setup_component(hass, COMPONENT.DOMAIN, GOOD_CONFIG)
-        self.hass.block_till_done()
+        await hass.async_block_till_done()
         for ident, port in ports.items():
             if ident != "bad":
                 mock_switch.assert_any_call(port)
-        assert mock.call(ports["bad"], self.hass) not in mock_switch.mock_calls
+        assert mock.call(ports["bad"], hass) not in mock_switch.mock_calls
 
 
-class TestMfiSwitch(unittest.TestCase):
+@pytest.fixture(name="port")
-    """Test for mFi switch platform."""
+def port_fixture():
+    """Port fixture."""
+    return mock.MagicMock()
 
-    def setup_method(self, method):
-        """Set up things to be run when tests are started."""
-        self.hass = get_test_home_assistant()
-        self.port = mock.MagicMock()
-        self.switch = mfi.MfiSwitch(self.port)
 
-    def teardown_method(self, method):
+@pytest.fixture(name="switch")
-        """Stop everything that was started."""
+def switch_fixture(port):
-        self.hass.stop()
+    """Switch fixture."""
+    return mfi.MfiSwitch(port)
 
-    def test_name(self):
+
+async def test_name(port, switch):
     """Test the name."""
-        assert self.port.label == self.switch.name
+    assert port.label == switch.name
 
-    def test_update(self):
+
+async def test_update(port, switch):
     """Test update."""
-        self.switch.update()
+    switch.update()
-        assert self.port.refresh.call_count == 1
+    assert port.refresh.call_count == 1
-        assert self.port.refresh.call_args == mock.call()
+    assert port.refresh.call_args == mock.call()
 
-    def test_update_with_target_state(self):
+
+async def test_update_with_target_state(port, switch):
     """Test update with target state."""
-        self.switch._target_state = True
+    # pylint: disable=protected-access
-        self.port.data = {}
+    switch._target_state = True
-        self.port.data["output"] = "stale"
+    port.data = {}
-        self.switch.update()
+    port.data["output"] = "stale"
-        assert 1.0 == self.port.data["output"]
+    switch.update()
-        assert self.switch._target_state is None
+    assert port.data["output"] == 1.0
-        self.port.data["output"] = "untouched"
+    # pylint: disable=protected-access
-        self.switch.update()
+    assert switch._target_state is None
-        assert "untouched" == self.port.data["output"]
+    port.data["output"] = "untouched"
+    switch.update()
+    assert port.data["output"] == "untouched"
 
-    def test_turn_on(self):
+
+async def test_turn_on(port, switch):
     """Test turn_on."""
-        self.switch.turn_on()
+    switch.turn_on()
-        assert self.port.control.call_count == 1
+    assert port.control.call_count == 1
-        assert self.port.control.call_args == mock.call(True)
+    assert port.control.call_args == mock.call(True)
-        assert self.switch._target_state
+    # pylint: disable=protected-access
+    assert switch._target_state
 
-    def test_turn_off(self):
+
+async def test_turn_off(port, switch):
     """Test turn_off."""
-        self.switch.turn_off()
+    switch.turn_off()
-        assert self.port.control.call_count == 1
+    assert port.control.call_count == 1
-        assert self.port.control.call_args == mock.call(False)
+    assert port.control.call_args == mock.call(False)
-        assert not self.switch._target_state
+    # pylint: disable=protected-access
+    assert not switch._target_state
 
-    def test_current_power_w(self):
+
+async def test_current_power_w(port, switch):
     """Test current power."""
-        self.port.data = {"active_pwr": 10}
+    port.data = {"active_pwr": 10}
-        assert 10 == self.switch.current_power_w
+    assert switch.current_power_w == 10
 
-    def test_current_power_w_no_data(self):
+
+async def test_current_power_w_no_data(port, switch):
     """Test current power if there is no data."""
-        self.port.data = {"notpower": 123}
+    port.data = {"notpower": 123}
-        assert 0 == self.switch.current_power_w
+    assert switch.current_power_w == 0
 
-    def test_device_state_attributes(self):
+
+async def test_device_state_attributes(port, switch):
     """Test the state attributes."""
-        self.port.data = {"v_rms": 1.25, "i_rms": 2.75}
+    port.data = {"v_rms": 1.25, "i_rms": 2.75}
-        assert {"volts": 1.2, "amps": 2.8} == self.switch.device_state_attributes
+    assert switch.device_state_attributes == {"volts": 1.2, "amps": 2.8}