Rewrite ecobee unittest tests to pytest (#42584)

tests/components/ecobee/test_climate.py

@@ -1,288 +1,310 @@
 """The test for the Ecobee thermostat module."""
-import unittest
 from unittest import mock
 
+import pytest
+
 from homeassistant.components.ecobee import climate as ecobee
 import homeassistant.const as const
 from homeassistant.const import STATE_OFF
 
 
-class TestEcobee(unittest.TestCase):
+@pytest.fixture
-    """Tests for Ecobee climate."""
+def ecobee_fixture():
-
+    """Set up ecobee mock."""
-    def setUp(self):
+    vals = {
-        """Set up test variables."""
+        "name": "Ecobee",
-        vals = {
+        "program": {
-            "name": "Ecobee",
+            "climates": [
-            "program": {
+                {"name": "Climate1", "climateRef": "c1"},
-                "climates": [
+                {"name": "Climate2", "climateRef": "c2"},
-                    {"name": "Climate1", "climateRef": "c1"},
-                    {"name": "Climate2", "climateRef": "c2"},
-                ],
-                "currentClimateRef": "c1",
-            },
-            "runtime": {
-                "actualTemperature": 300,
-                "actualHumidity": 15,
-                "desiredHeat": 400,
-                "desiredCool": 200,
-                "desiredFanMode": "on",
-            },
-            "settings": {
-                "hvacMode": "auto",
-                "heatStages": 1,
-                "coolStages": 1,
-                "fanMinOnTime": 10,
-                "heatCoolMinDelta": 50,
-                "holdAction": "nextTransition",
-            },
-            "equipmentStatus": "fan",
-            "events": [
-                {
-                    "name": "Event1",
-                    "running": True,
-                    "type": "hold",
-                    "holdClimateRef": "away",
-                    "endDate": "2017-01-01 10:00:00",
-                    "startDate": "2017-02-02 11:00:00",
-                }
             ],
-        }
+            "currentClimateRef": "c1",
+        },
+        "runtime": {
+            "actualTemperature": 300,
+            "actualHumidity": 15,
+            "desiredHeat": 400,
+            "desiredCool": 200,
+            "desiredFanMode": "on",
+        },
+        "settings": {
+            "hvacMode": "auto",
+            "heatStages": 1,
+            "coolStages": 1,
+            "fanMinOnTime": 10,
+            "heatCoolMinDelta": 50,
+            "holdAction": "nextTransition",
+        },
+        "equipmentStatus": "fan",
+        "events": [
+            {
+                "name": "Event1",
+                "running": True,
+                "type": "hold",
+                "holdClimateRef": "away",
+                "endDate": "2017-01-01 10:00:00",
+                "startDate": "2017-02-02 11:00:00",
+            }
+        ],
+    }
+    mock_ecobee = mock.Mock()
+    mock_ecobee.__getitem__ = mock.Mock(side_effect=vals.__getitem__)
+    mock_ecobee.__setitem__ = mock.Mock(side_effect=vals.__setitem__)
+    return mock_ecobee
 
-        self.ecobee = mock.Mock()
-        self.ecobee.__getitem__ = mock.Mock(side_effect=vals.__getitem__)
-        self.ecobee.__setitem__ = mock.Mock(side_effect=vals.__setitem__)
 
-        self.data = mock.Mock()
+@pytest.fixture(name="data")
-        self.data.ecobee.get_thermostat.return_value = self.ecobee
+def data_fixture(ecobee_fixture):
-        self.thermostat = ecobee.Thermostat(self.data, 1)
+    """Set up data mock."""
+    data = mock.Mock()
+    data.ecobee.get_thermostat.return_value = ecobee_fixture
+    return data
 
-    def test_name(self):
-        """Test name property."""
-        assert "Ecobee" == self.thermostat.name
 
-    def test_current_temperature(self):
+@pytest.fixture(name="thermostat")
-        """Test current temperature."""
+def thermostat_fixture(data):
-        assert 30 == self.thermostat.current_temperature
+    """Set up ecobee thermostat object."""
-        self.ecobee["runtime"]["actualTemperature"] = const.HTTP_NOT_FOUND
+    return ecobee.Thermostat(data, 1)
-        assert 40.4 == self.thermostat.current_temperature
 
-    def test_target_temperature_low(self):
-        """Test target low temperature."""
-        assert 40 == self.thermostat.target_temperature_low
-        self.ecobee["runtime"]["desiredHeat"] = 502
-        assert 50.2 == self.thermostat.target_temperature_low
 
-    def test_target_temperature_high(self):
+async def test_name(thermostat):
-        """Test target high temperature."""
+    """Test name property."""
-        assert 20 == self.thermostat.target_temperature_high
+    assert thermostat.name == "Ecobee"
-        self.ecobee["runtime"]["desiredCool"] = 103
-        assert 10.3 == self.thermostat.target_temperature_high
 
-    def test_target_temperature(self):
-        """Test target temperature."""
-        assert self.thermostat.target_temperature is None
-        self.ecobee["settings"]["hvacMode"] = "heat"
-        assert 40 == self.thermostat.target_temperature
-        self.ecobee["settings"]["hvacMode"] = "cool"
-        assert 20 == self.thermostat.target_temperature
-        self.ecobee["settings"]["hvacMode"] = "auxHeatOnly"
-        assert 40 == self.thermostat.target_temperature
-        self.ecobee["settings"]["hvacMode"] = "off"
-        assert self.thermostat.target_temperature is None
 
-    def test_desired_fan_mode(self):
+async def test_current_temperature(ecobee_fixture, thermostat):
-        """Test desired fan mode property."""
+    """Test current temperature."""
-        assert "on" == self.thermostat.fan_mode
+    assert thermostat.current_temperature == 30
-        self.ecobee["runtime"]["desiredFanMode"] = "auto"
+    ecobee_fixture["runtime"]["actualTemperature"] = const.HTTP_NOT_FOUND
-        assert "auto" == self.thermostat.fan_mode
+    assert thermostat.current_temperature == 40.4
 
-    def test_fan(self):
-        """Test fan property."""
-        assert const.STATE_ON == self.thermostat.fan
-        self.ecobee["equipmentStatus"] = ""
-        assert STATE_OFF == self.thermostat.fan
-        self.ecobee["equipmentStatus"] = "heatPump, heatPump2"
-        assert STATE_OFF == self.thermostat.fan
 
-    def test_hvac_mode(self):
+async def test_target_temperature_low(ecobee_fixture, thermostat):
-        """Test current operation property."""
+    """Test target low temperature."""
-        assert self.thermostat.hvac_mode == "heat_cool"
+    assert thermostat.target_temperature_low == 40
-        self.ecobee["settings"]["hvacMode"] = "heat"
+    ecobee_fixture["runtime"]["desiredHeat"] = 502
-        assert self.thermostat.hvac_mode == "heat"
+    assert thermostat.target_temperature_low == 50.2
-        self.ecobee["settings"]["hvacMode"] = "cool"
-        assert self.thermostat.hvac_mode == "cool"
-        self.ecobee["settings"]["hvacMode"] = "auxHeatOnly"
-        assert self.thermostat.hvac_mode == "heat"
-        self.ecobee["settings"]["hvacMode"] = "off"
-        assert self.thermostat.hvac_mode == "off"
 
-    def test_hvac_modes(self):
-        """Test operation list property."""
-        assert ["heat_cool", "heat", "cool", "off"] == self.thermostat.hvac_modes
 
-    def test_hvac_mode2(self):
+async def test_target_temperature_high(ecobee_fixture, thermostat):
-        """Test operation mode property."""
+    """Test target high temperature."""
-        assert self.thermostat.hvac_mode == "heat_cool"
+    assert thermostat.target_temperature_high == 20
-        self.ecobee["settings"]["hvacMode"] = "heat"
+    ecobee_fixture["runtime"]["desiredCool"] = 103
-        assert self.thermostat.hvac_mode == "heat"
+    assert thermostat.target_temperature_high == 10.3
 
-    def test_device_state_attributes(self):
-        """Test device state attributes property."""
-        self.ecobee["equipmentStatus"] = "heatPump2"
-        assert {
-            "fan": "off",
-            "climate_mode": "Climate1",
-            "fan_min_on_time": 10,
-            "equipment_running": "heatPump2",
-        } == self.thermostat.device_state_attributes
 
-        self.ecobee["equipmentStatus"] = "auxHeat2"
+async def test_target_temperature(ecobee_fixture, thermostat):
-        assert {
+    """Test target temperature."""
-            "fan": "off",
+    assert thermostat.target_temperature is None
-            "climate_mode": "Climate1",
+    ecobee_fixture["settings"]["hvacMode"] = "heat"
-            "fan_min_on_time": 10,
+    assert thermostat.target_temperature == 40
-            "equipment_running": "auxHeat2",
+    ecobee_fixture["settings"]["hvacMode"] = "cool"
-        } == self.thermostat.device_state_attributes
+    assert thermostat.target_temperature == 20
-        self.ecobee["equipmentStatus"] = "compCool1"
+    ecobee_fixture["settings"]["hvacMode"] = "auxHeatOnly"
-        assert {
+    assert thermostat.target_temperature == 40
-            "fan": "off",
+    ecobee_fixture["settings"]["hvacMode"] = "off"
-            "climate_mode": "Climate1",
+    assert thermostat.target_temperature is None
-            "fan_min_on_time": 10,
-            "equipment_running": "compCool1",
-        } == self.thermostat.device_state_attributes
-        self.ecobee["equipmentStatus"] = ""
-        assert {
-            "fan": "off",
-            "climate_mode": "Climate1",
-            "fan_min_on_time": 10,
-            "equipment_running": "",
-        } == self.thermostat.device_state_attributes
 
-        self.ecobee["equipmentStatus"] = "Unknown"
-        assert {
-            "fan": "off",
-            "climate_mode": "Climate1",
-            "fan_min_on_time": 10,
-            "equipment_running": "Unknown",
-        } == self.thermostat.device_state_attributes
 
-        self.ecobee["program"]["currentClimateRef"] = "c2"
+async def test_desired_fan_mode(ecobee_fixture, thermostat):
-        assert {
+    """Test desired fan mode property."""
-            "fan": "off",
+    assert thermostat.fan_mode == "on"
-            "climate_mode": "Climate2",
+    ecobee_fixture["runtime"]["desiredFanMode"] = "auto"
-            "fan_min_on_time": 10,
+    assert thermostat.fan_mode == "auto"
-            "equipment_running": "Unknown",
-        } == self.thermostat.device_state_attributes
 
-    def test_is_aux_heat_on(self):
-        """Test aux heat property."""
-        assert not self.thermostat.is_aux_heat
-        self.ecobee["equipmentStatus"] = "fan, auxHeat"
-        assert self.thermostat.is_aux_heat
 
-    def test_set_temperature(self):
+async def test_fan(ecobee_fixture, thermostat):
-        """Test set temperature."""
+    """Test fan property."""
-        # Auto -> Auto
+    assert const.STATE_ON == thermostat.fan
-        self.data.reset_mock()
+    ecobee_fixture["equipmentStatus"] = ""
-        self.thermostat.set_temperature(target_temp_low=20, target_temp_high=30)
+    assert STATE_OFF == thermostat.fan
-        self.data.ecobee.set_hold_temp.assert_has_calls(
+    ecobee_fixture["equipmentStatus"] = "heatPump, heatPump2"
-            [mock.call(1, 30, 20, "nextTransition")]
+    assert STATE_OFF == thermostat.fan
-        )
 
-        # Auto -> Hold
-        self.data.reset_mock()
-        self.thermostat.set_temperature(temperature=20)
-        self.data.ecobee.set_hold_temp.assert_has_calls(
-            [mock.call(1, 25, 15, "nextTransition")]
-        )
 
-        # Cool -> Hold
+async def test_hvac_mode(ecobee_fixture, thermostat):
-        self.data.reset_mock()
+    """Test current operation property."""
-        self.ecobee["settings"]["hvacMode"] = "cool"
+    assert thermostat.hvac_mode == "heat_cool"
-        self.thermostat.set_temperature(temperature=20.5)
+    ecobee_fixture["settings"]["hvacMode"] = "heat"
-        self.data.ecobee.set_hold_temp.assert_has_calls(
+    assert thermostat.hvac_mode == "heat"
-            [mock.call(1, 20.5, 20.5, "nextTransition")]
+    ecobee_fixture["settings"]["hvacMode"] = "cool"
-        )
+    assert thermostat.hvac_mode == "cool"
+    ecobee_fixture["settings"]["hvacMode"] = "auxHeatOnly"
+    assert thermostat.hvac_mode == "heat"
+    ecobee_fixture["settings"]["hvacMode"] = "off"
+    assert thermostat.hvac_mode == "off"
 
-        # Heat -> Hold
-        self.data.reset_mock()
-        self.ecobee["settings"]["hvacMode"] = "heat"
-        self.thermostat.set_temperature(temperature=20)
-        self.data.ecobee.set_hold_temp.assert_has_calls(
-            [mock.call(1, 20, 20, "nextTransition")]
-        )
 
-        # Heat -> Auto
+async def test_hvac_modes(thermostat):
-        self.data.reset_mock()
+    """Test operation list property."""
-        self.ecobee["settings"]["hvacMode"] = "heat"
+    assert ["heat_cool", "heat", "cool", "off"] == thermostat.hvac_modes
-        self.thermostat.set_temperature(target_temp_low=20, target_temp_high=30)
-        assert not self.data.ecobee.set_hold_temp.called
 
-    def test_set_hvac_mode(self):
-        """Test operation mode setter."""
-        self.data.reset_mock()
-        self.thermostat.set_hvac_mode("heat_cool")
-        self.data.ecobee.set_hvac_mode.assert_has_calls([mock.call(1, "auto")])
-        self.data.reset_mock()
-        self.thermostat.set_hvac_mode("heat")
-        self.data.ecobee.set_hvac_mode.assert_has_calls([mock.call(1, "heat")])
 
-    def test_set_fan_min_on_time(self):
+async def test_hvac_mode2(ecobee_fixture, thermostat):
-        """Test fan min on time setter."""
+    """Test operation mode property."""
-        self.data.reset_mock()
+    assert thermostat.hvac_mode == "heat_cool"
-        self.thermostat.set_fan_min_on_time(15)
+    ecobee_fixture["settings"]["hvacMode"] = "heat"
-        self.data.ecobee.set_fan_min_on_time.assert_has_calls([mock.call(1, 15)])
+    assert thermostat.hvac_mode == "heat"
-        self.data.reset_mock()
-        self.thermostat.set_fan_min_on_time(20)
-        self.data.ecobee.set_fan_min_on_time.assert_has_calls([mock.call(1, 20)])
 
-    def test_resume_program(self):
-        """Test resume program."""
-        # False
-        self.data.reset_mock()
-        self.thermostat.resume_program(False)
-        self.data.ecobee.resume_program.assert_has_calls([mock.call(1, "false")])
-        self.data.reset_mock()
-        self.thermostat.resume_program(None)
-        self.data.ecobee.resume_program.assert_has_calls([mock.call(1, "false")])
-        self.data.reset_mock()
-        self.thermostat.resume_program(0)
-        self.data.ecobee.resume_program.assert_has_calls([mock.call(1, "false")])
 
-        # True
+async def test_device_state_attributes(ecobee_fixture, thermostat):
-        self.data.reset_mock()
+    """Test device state attributes property."""
-        self.thermostat.resume_program(True)
+    ecobee_fixture["equipmentStatus"] = "heatPump2"
-        self.data.ecobee.resume_program.assert_has_calls([mock.call(1, "true")])
+    assert {
-        self.data.reset_mock()
+        "fan": "off",
-        self.thermostat.resume_program(1)
+        "climate_mode": "Climate1",
-        self.data.ecobee.resume_program.assert_has_calls([mock.call(1, "true")])
+        "fan_min_on_time": 10,
+        "equipment_running": "heatPump2",
+    } == thermostat.device_state_attributes
 
-    def test_hold_preference(self):
+    ecobee_fixture["equipmentStatus"] = "auxHeat2"
-        """Test hold preference."""
+    assert {
-        assert "nextTransition" == self.thermostat.hold_preference()
+        "fan": "off",
-        for action in [
+        "climate_mode": "Climate1",
-            "useEndTime4hour",
+        "fan_min_on_time": 10,
-            "useEndTime2hour",
+        "equipment_running": "auxHeat2",
-            "nextPeriod",
+    } == thermostat.device_state_attributes
-            "indefinite",
+    ecobee_fixture["equipmentStatus"] = "compCool1"
-            "askMe",
+    assert {
-        ]:
+        "fan": "off",
-            self.ecobee["settings"]["holdAction"] = action
+        "climate_mode": "Climate1",
-            assert "nextTransition" == self.thermostat.hold_preference()
+        "fan_min_on_time": 10,
+        "equipment_running": "compCool1",
+    } == thermostat.device_state_attributes
+    ecobee_fixture["equipmentStatus"] = ""
+    assert {
+        "fan": "off",
+        "climate_mode": "Climate1",
+        "fan_min_on_time": 10,
+        "equipment_running": "",
+    } == thermostat.device_state_attributes
 
-    def test_set_fan_mode_on(self):
+    ecobee_fixture["equipmentStatus"] = "Unknown"
-        """Test set fan mode to on."""
+    assert {
-        self.data.reset_mock()
+        "fan": "off",
-        self.thermostat.set_fan_mode("on")
+        "climate_mode": "Climate1",
-        self.data.ecobee.set_fan_mode.assert_has_calls(
+        "fan_min_on_time": 10,
-            [mock.call(1, "on", 20, 40, "nextTransition")]
+        "equipment_running": "Unknown",
-        )
+    } == thermostat.device_state_attributes
 
-    def test_set_fan_mode_auto(self):
+    ecobee_fixture["program"]["currentClimateRef"] = "c2"
-        """Test set fan mode to auto."""
+    assert {
-        self.data.reset_mock()
+        "fan": "off",
-        self.thermostat.set_fan_mode("auto")
+        "climate_mode": "Climate2",
-        self.data.ecobee.set_fan_mode.assert_has_calls(
+        "fan_min_on_time": 10,
-            [mock.call(1, "auto", 20, 40, "nextTransition")]
+        "equipment_running": "Unknown",
-        )
+    } == thermostat.device_state_attributes
+
+
+async def test_is_aux_heat_on(ecobee_fixture, thermostat):
+    """Test aux heat property."""
+    assert not thermostat.is_aux_heat
+    ecobee_fixture["equipmentStatus"] = "fan, auxHeat"
+    assert thermostat.is_aux_heat
+
+
+async def test_set_temperature(ecobee_fixture, thermostat, data):
+    """Test set temperature."""
+    # Auto -> Auto
+    data.reset_mock()
+    thermostat.set_temperature(target_temp_low=20, target_temp_high=30)
+    data.ecobee.set_hold_temp.assert_has_calls([mock.call(1, 30, 20, "nextTransition")])
+
+    # Auto -> Hold
+    data.reset_mock()
+    thermostat.set_temperature(temperature=20)
+    data.ecobee.set_hold_temp.assert_has_calls([mock.call(1, 25, 15, "nextTransition")])
+
+    # Cool -> Hold
+    data.reset_mock()
+    ecobee_fixture["settings"]["hvacMode"] = "cool"
+    thermostat.set_temperature(temperature=20.5)
+    data.ecobee.set_hold_temp.assert_has_calls(
+        [mock.call(1, 20.5, 20.5, "nextTransition")]
+    )
+
+    # Heat -> Hold
+    data.reset_mock()
+    ecobee_fixture["settings"]["hvacMode"] = "heat"
+    thermostat.set_temperature(temperature=20)
+    data.ecobee.set_hold_temp.assert_has_calls([mock.call(1, 20, 20, "nextTransition")])
+
+    # Heat -> Auto
+    data.reset_mock()
+    ecobee_fixture["settings"]["hvacMode"] = "heat"
+    thermostat.set_temperature(target_temp_low=20, target_temp_high=30)
+    assert not data.ecobee.set_hold_temp.called
+
+
+async def test_set_hvac_mode(thermostat, data):
+    """Test operation mode setter."""
+    data.reset_mock()
+    thermostat.set_hvac_mode("heat_cool")
+    data.ecobee.set_hvac_mode.assert_has_calls([mock.call(1, "auto")])
+    data.reset_mock()
+    thermostat.set_hvac_mode("heat")
+    data.ecobee.set_hvac_mode.assert_has_calls([mock.call(1, "heat")])
+
+
+async def test_set_fan_min_on_time(thermostat, data):
+    """Test fan min on time setter."""
+    data.reset_mock()
+    thermostat.set_fan_min_on_time(15)
+    data.ecobee.set_fan_min_on_time.assert_has_calls([mock.call(1, 15)])
+    data.reset_mock()
+    thermostat.set_fan_min_on_time(20)
+    data.ecobee.set_fan_min_on_time.assert_has_calls([mock.call(1, 20)])
+
+
+async def test_resume_program(thermostat, data):
+    """Test resume program."""
+    # False
+    data.reset_mock()
+    thermostat.resume_program(False)
+    data.ecobee.resume_program.assert_has_calls([mock.call(1, "false")])
+    data.reset_mock()
+    thermostat.resume_program(None)
+    data.ecobee.resume_program.assert_has_calls([mock.call(1, "false")])
+    data.reset_mock()
+    thermostat.resume_program(0)
+    data.ecobee.resume_program.assert_has_calls([mock.call(1, "false")])
+
+    # True
+    data.reset_mock()
+    thermostat.resume_program(True)
+    data.ecobee.resume_program.assert_has_calls([mock.call(1, "true")])
+    data.reset_mock()
+    thermostat.resume_program(1)
+    data.ecobee.resume_program.assert_has_calls([mock.call(1, "true")])
+
+
+async def test_hold_preference(ecobee_fixture, thermostat):
+    """Test hold preference."""
+    assert thermostat.hold_preference() == "nextTransition"
+    for action in [
+        "useEndTime4hour",
+        "useEndTime2hour",
+        "nextPeriod",
+        "indefinite",
+        "askMe",
+    ]:
+        ecobee_fixture["settings"]["holdAction"] = action
+        assert thermostat.hold_preference() == "nextTransition"
+
+
+async def test_set_fan_mode_on(thermostat, data):
+    """Test set fan mode to on."""
+    data.reset_mock()
+    thermostat.set_fan_mode("on")
+    data.ecobee.set_fan_mode.assert_has_calls(
+        [mock.call(1, "on", 20, 40, "nextTransition")]
+    )
+
+
+async def test_set_fan_mode_auto(thermostat, data):
+    """Test set fan mode to auto."""
+    data.reset_mock()
+    thermostat.set_fan_mode("auto")
+    data.ecobee.set_fan_mode.assert_has_calls(
+        [mock.call(1, "auto", 20, 40, "nextTransition")]
+    )

tests/components/ecobee/test_config_flow.py

@@ -46,8 +46,8 @@ async def test_pin_request_succeeds(hass):
     flow.hass = hass
     flow.hass.data[DATA_ECOBEE_CONFIG] = {}
 
-    with patch("homeassistant.components.ecobee.config_flow.Ecobee") as MockEcobee:
+    with patch("homeassistant.components.ecobee.config_flow.Ecobee") as mock_ecobee:
-        mock_ecobee = MockEcobee.return_value
+        mock_ecobee = mock_ecobee.return_value
         mock_ecobee.request_pin.return_value = True
         mock_ecobee.pin = "test-pin"
 
@@ -64,8 +64,8 @@ async def test_pin_request_fails(hass):
     flow.hass = hass
     flow.hass.data[DATA_ECOBEE_CONFIG] = {}
 
-    with patch("homeassistant.components.ecobee.config_flow.Ecobee") as MockEcobee:
+    with patch("homeassistant.components.ecobee.config_flow.Ecobee") as mock_ecobee:
-        mock_ecobee = MockEcobee.return_value
+        mock_ecobee = mock_ecobee.return_value
         mock_ecobee.request_pin.return_value = False
 
         result = await flow.async_step_user(user_input={CONF_API_KEY: "api-key"})
@@ -81,12 +81,14 @@ async def test_token_request_succeeds(hass):
     flow.hass = hass
     flow.hass.data[DATA_ECOBEE_CONFIG] = {}
 
-    with patch("homeassistant.components.ecobee.config_flow.Ecobee") as MockEcobee:
+    with patch("homeassistant.components.ecobee.config_flow.Ecobee") as mock_ecobee:
-        mock_ecobee = MockEcobee.return_value
+        mock_ecobee = mock_ecobee.return_value
         mock_ecobee.request_tokens.return_value = True
         mock_ecobee.api_key = "test-api-key"
         mock_ecobee.refresh_token = "test-token"
+        # pylint: disable=protected-access
         flow._ecobee = mock_ecobee
+        # pylint: enable=protected-access
 
         result = await flow.async_step_authorize(user_input={})
 
@@ -104,11 +106,13 @@ async def test_token_request_fails(hass):
     flow.hass = hass
     flow.hass.data[DATA_ECOBEE_CONFIG] = {}
 
-    with patch("homeassistant.components.ecobee.config_flow.Ecobee") as MockEcobee:
+    with patch("homeassistant.components.ecobee.config_flow.Ecobee") as mock_ecobee:
-        mock_ecobee = MockEcobee.return_value
+        mock_ecobee = mock_ecobee.return_value
         mock_ecobee.request_tokens.return_value = False
         mock_ecobee.pin = "test-pin"
+        # pylint: disable=protected-access
         flow._ecobee = mock_ecobee
+        # pylint: enable=protected-access
 
         result = await flow.async_step_authorize(user_input={})
 
@@ -143,8 +147,8 @@ async def test_import_flow_triggered_with_ecobee_conf_and_valid_data_and_valid_t
     with patch(
         "homeassistant.components.ecobee.config_flow.load_json",
         return_value=MOCK_ECOBEE_CONF,
-    ), patch("homeassistant.components.ecobee.config_flow.Ecobee") as MockEcobee:
+    ), patch("homeassistant.components.ecobee.config_flow.Ecobee") as mock_ecobee:
-        mock_ecobee = MockEcobee.return_value
+        mock_ecobee = mock_ecobee.return_value
         mock_ecobee.refresh_tokens.return_value = True
         mock_ecobee.api_key = "test-api-key"
         mock_ecobee.refresh_token = "test-token"
@@ -196,10 +200,10 @@ async def test_import_flow_triggered_with_ecobee_conf_and_valid_data_and_stale_t
         return_value=MOCK_ECOBEE_CONF,
     ), patch(
         "homeassistant.components.ecobee.config_flow.Ecobee"
-    ) as MockEcobee, patch.object(
+    ) as mock_ecobee, patch.object(
         flow, "async_step_user", return_value=mock_coro()
     ) as mock_async_step_user:
-        mock_ecobee = MockEcobee.return_value
+        mock_ecobee = mock_ecobee.return_value
         mock_ecobee.refresh_tokens.return_value = False
 
         await flow.async_step_import(import_data=None)

tests/components/ecobee/test_util.py

@@ -5,14 +5,14 @@ import voluptuous as vol
 from homeassistant.components.ecobee.util import ecobee_date, ecobee_time
 
 
-def test_ecobee_date_with_valid_input():
+async def test_ecobee_date_with_valid_input():
     """Test that the date function returns the expected result."""
     test_input = "2019-09-27"
 
     assert ecobee_date(test_input) == test_input
 
 
-def test_ecobee_date_with_invalid_input():
+async def test_ecobee_date_with_invalid_input():
     """Test that the date function raises the expected exception."""
     test_input = "20190927"
 
@@ -20,14 +20,14 @@ def test_ecobee_date_with_invalid_input():
         ecobee_date(test_input)
 
 
-def test_ecobee_time_with_valid_input():
+async def test_ecobee_time_with_valid_input():
     """Test that the time function returns the expected result."""
     test_input = "20:55:15"
 
     assert ecobee_time(test_input) == test_input
 
 
-def test_ecobee_time_with_invalid_input():
+async def test_ecobee_time_with_invalid_input():
     """Test that the time function raises the expected exception."""
     test_input = "20:55"