diff --git a/tests/components/mfi/test_sensor.py b/tests/components/mfi/test_sensor.py index 05e1379cfb4..39e67d87958 100644 --- a/tests/components/mfi/test_sensor.py +++ b/tests/components/mfi/test_sensor.py @@ -1,105 +1,101 @@ """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 - -class TestMfiSensorSetup(unittest.TestCase): - """Test the mFi sensor platform.""" - - PLATFORM = mfi - COMPONENT = sensor - THING = "sensor" - GOOD_CONFIG = { - "sensor": { - "platform": "mfi", - "host": "foo", - "port": 6123, - "username": "user", - "password": "pass", - "ssl": True, - "verify_ssl": True, - } +PLATFORM = mfi +COMPONENT = sensor_component +THING = "sensor" +GOOD_CONFIG = { + "sensor": { + "platform": "mfi", + "host": "foo", + "port": 6123, + "username": "user", + "password": "pass", + "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): - """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.""" +async def test_setup_missing_config(hass): + """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): - """Test setup with login failure.""" + +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): - """Test setup with connection failure.""" + +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): - """Test setup with minimum configuration.""" - config = dict(self.GOOD_CONFIG) - del config[self.THING]["port"] - assert setup_component(self.hass, self.COMPONENT.DOMAIN, config) - self.hass.block_till_done() + +async def test_setup_minimum(hass): + """Test setup with minimum configuration.""" + with mock.patch("homeassistant.components.mfi.sensor.MFiClient") as mock_client: + config = dict(GOOD_CONFIG) + del config[THING]["port"] + 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): - """Test setup with port.""" - config = dict(self.GOOD_CONFIG) - config[self.THING]["port"] = 6123 - assert setup_component(self.hass, self.COMPONENT.DOMAIN, config) - self.hass.block_till_done() + +async def test_setup_with_port(hass): + """Test setup with port.""" + with mock.patch("homeassistant.components.mfi.sensor.MFiClient") as mock_client: + config = dict(GOOD_CONFIG) + config[THING]["port"] = 6123 + 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): - """Test setup without TLS.""" - config = dict(self.GOOD_CONFIG) - del config[self.THING]["port"] - config[self.THING]["ssl"] = False - config[self.THING]["verify_ssl"] = False - assert setup_component(self.hass, self.COMPONENT.DOMAIN, config) - self.hass.block_till_done() + +async def test_setup_with_tls_disabled(hass): + """Test setup without TLS.""" + with mock.patch("homeassistant.components.mfi.sensor.MFiClient") as mock_client: + config = dict(GOOD_CONFIG) + del config[THING]["port"] + config[THING]["ssl"] = False + config[THING]["verify_ssl"] = False + 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") - def test_setup_adds_proper_devices(self, mock_sensor, mock_client): - """Test if setup adds devices.""" + +async def test_setup_adds_proper_devices(hass): + """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) - self.hass.block_till_done() + assert await async_setup_component(hass, COMPONENT.DOMAIN, GOOD_CONFIG) + await hass.async_block_till_done() for ident, port in ports.items(): if ident != "bad": - mock_sensor.assert_any_call(port, self.hass) - assert mock.call(ports["bad"], self.hass) not in mock_sensor.mock_calls + mock_sensor.assert_any_call(port, hass) + assert mock.call(ports["bad"], hass) not in mock_sensor.mock_calls -class TestMfiSensor(unittest.TestCase): - """Test for mFi sensor platform.""" +@pytest.fixture(name="port") +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): - """Stop everything that was started.""" - self.hass.stop() +@pytest.fixture(name="sensor") +def sensor_fixture(hass, port): + """Sensor fixture.""" + return mfi.MfiSensor(port, hass) - def test_name(self): - """Test the name.""" - assert self.port.label == self.sensor.name - def test_uom_temp(self): - """Test the UOM temperature.""" - self.port.tag = "temperature" - assert TEMP_CELSIUS == self.sensor.unit_of_measurement +async def test_name(port, sensor): + """Test the name.""" + assert port.label == sensor.name - def test_uom_power(self): - """Test the UOEM power.""" - self.port.tag = "active_pwr" - assert "Watts" == self.sensor.unit_of_measurement - def test_uom_digital(self): - """Test the UOM digital input.""" - self.port.model = "Input Digital" - assert "State" == self.sensor.unit_of_measurement +async def test_uom_temp(port, sensor): + """Test the UOM temperature.""" + port.tag = "temperature" + assert TEMP_CELSIUS == sensor.unit_of_measurement - def test_uom_unknown(self): - """Test the UOM.""" - self.port.tag = "balloons" - assert "balloons" == self.sensor.unit_of_measurement - def test_uom_uninitialized(self): - """Test that the UOM defaults if not initialized.""" - type(self.port).tag = mock.PropertyMock(side_effect=ValueError) - assert "State" == self.sensor.unit_of_measurement +async def test_uom_power(port, sensor): + """Test the UOEM power.""" + port.tag = "active_pwr" + assert sensor.unit_of_measurement == "Watts" - def test_state_digital(self): - """Test the digital input.""" - self.port.model = "Input Digital" - self.port.value = 0 - assert mfi.STATE_OFF == self.sensor.state - self.port.value = 1 - assert mfi.STATE_ON == self.sensor.state - self.port.value = 2 - assert mfi.STATE_ON == self.sensor.state - def test_state_digits(self): - """Test the state of digits.""" - self.port.tag = "didyoucheckthedict?" - self.port.value = 1.25 - with mock.patch.dict(mfi.DIGITS, {"didyoucheckthedict?": 1}): - assert 1.2 == self.sensor.state - with mock.patch.dict(mfi.DIGITS, {}): - assert 1.0 == self.sensor.state +async def test_uom_digital(port, sensor): + """Test the UOM digital input.""" + port.model = "Input Digital" + assert sensor.unit_of_measurement == "State" - 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): - """Test the update.""" - self.sensor.update() - assert self.port.refresh.call_count == 1 - assert self.port.refresh.call_args == mock.call() +async def test_uom_unknown(port, sensor): + """Test the UOM.""" + port.tag = "balloons" + assert sensor.unit_of_measurement == "balloons" + + +async def test_uom_uninitialized(port, sensor): + """Test that the UOM defaults if not initialized.""" + type(port).tag = mock.PropertyMock(side_effect=ValueError) + assert sensor.unit_of_measurement == "State" + + +async def test_state_digital(port, sensor): + """Test the digital input.""" + port.model = "Input Digital" + port.value = 0 + assert mfi.STATE_OFF == sensor.state + port.value = 1 + assert mfi.STATE_ON == sensor.state + port.value = 2 + assert mfi.STATE_ON == sensor.state + + +async def test_state_digits(port, sensor): + """Test the state of digits.""" + port.tag = "didyoucheckthedict?" + port.value = 1.25 + with mock.patch.dict(mfi.DIGITS, {"didyoucheckthedict?": 1}): + assert sensor.state == 1.2 + with mock.patch.dict(mfi.DIGITS, {}): + assert sensor.state == 1.0 + + +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.""" + sensor.update() + assert port.refresh.call_count == 1 + assert port.refresh.call_args == mock.call() diff --git a/tests/components/mfi/test_switch.py b/tests/components/mfi/test_switch.py index 45bb3530266..77a7a72da9e 100644 --- a/tests/components/mfi/test_switch.py +++ b/tests/components/mfi/test_switch.py @@ -1,44 +1,35 @@ """The tests for the mFi switch platform.""" -import unittest +import pytest import homeassistant.components.mfi.switch as mfi -import homeassistant.components.switch as switch -from homeassistant.setup import setup_component +import homeassistant.components.switch as switch_component +from homeassistant.setup import async_setup_component import tests.async_mock as mock -from tests.common import get_test_home_assistant - -class TestMfiSwitchSetup(unittest.TestCase): - """Test the mFi switch.""" - - PLATFORM = mfi - COMPONENT = switch - THING = "switch" - GOOD_CONFIG = { - "switch": { - "platform": "mfi", - "host": "foo", - "port": 6123, - "username": "user", - "password": "pass", - "ssl": True, - "verify_ssl": True, - } +PLATFORM = mfi +COMPONENT = switch_component +THING = "switch" +GOOD_CONFIG = { + "switch": { + "platform": "mfi", + "host": "foo", + "port": 6123, + "username": "user", + "password": "pass", + "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): - """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.""" +async def test_setup_adds_proper_devices(hass): + """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) - self.hass.block_till_done() + assert await async_setup_component(hass, COMPONENT.DOMAIN, GOOD_CONFIG) + 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): - """Test for mFi switch platform.""" +@pytest.fixture(name="port") +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): - """Stop everything that was started.""" - self.hass.stop() +@pytest.fixture(name="switch") +def switch_fixture(port): + """Switch fixture.""" + return mfi.MfiSwitch(port) - def test_name(self): - """Test the name.""" - assert self.port.label == self.switch.name - def test_update(self): - """Test update.""" - self.switch.update() - assert self.port.refresh.call_count == 1 - assert self.port.refresh.call_args == mock.call() +async def test_name(port, switch): + """Test the name.""" + assert port.label == switch.name - def test_update_with_target_state(self): - """Test update with target state.""" - self.switch._target_state = True - self.port.data = {} - self.port.data["output"] = "stale" - self.switch.update() - assert 1.0 == self.port.data["output"] - assert self.switch._target_state is None - self.port.data["output"] = "untouched" - self.switch.update() - assert "untouched" == self.port.data["output"] - def test_turn_on(self): - """Test turn_on.""" - self.switch.turn_on() - assert self.port.control.call_count == 1 - assert self.port.control.call_args == mock.call(True) - assert self.switch._target_state +async def test_update(port, switch): + """Test update.""" + switch.update() + assert port.refresh.call_count == 1 + assert port.refresh.call_args == mock.call() - def test_turn_off(self): - """Test turn_off.""" - self.switch.turn_off() - assert self.port.control.call_count == 1 - assert self.port.control.call_args == mock.call(False) - assert not self.switch._target_state - def test_current_power_w(self): - """Test current power.""" - self.port.data = {"active_pwr": 10} - assert 10 == self.switch.current_power_w +async def test_update_with_target_state(port, switch): + """Test update with target state.""" + # pylint: disable=protected-access + switch._target_state = True + port.data = {} + port.data["output"] = "stale" + switch.update() + assert port.data["output"] == 1.0 + # pylint: disable=protected-access + assert switch._target_state is None + port.data["output"] = "untouched" + switch.update() + assert port.data["output"] == "untouched" - def test_current_power_w_no_data(self): - """Test current power if there is no data.""" - self.port.data = {"notpower": 123} - assert 0 == self.switch.current_power_w - def test_device_state_attributes(self): - """Test the state attributes.""" - self.port.data = {"v_rms": 1.25, "i_rms": 2.75} - assert {"volts": 1.2, "amps": 2.8} == self.switch.device_state_attributes +async def test_turn_on(port, switch): + """Test turn_on.""" + switch.turn_on() + assert port.control.call_count == 1 + assert port.control.call_args == mock.call(True) + # pylint: disable=protected-access + assert switch._target_state + + +async def test_turn_off(port, switch): + """Test turn_off.""" + switch.turn_off() + assert port.control.call_count == 1 + assert port.control.call_args == mock.call(False) + # pylint: disable=protected-access + assert not switch._target_state + + +async def test_current_power_w(port, switch): + """Test current power.""" + port.data = {"active_pwr": 10} + assert switch.current_power_w == 10 + + +async def test_current_power_w_no_data(port, switch): + """Test current power if there is no data.""" + port.data = {"notpower": 123} + assert switch.current_power_w == 0 + + +async def test_device_state_attributes(port, switch): + """Test the state attributes.""" + port.data = {"v_rms": 1.25, "i_rms": 2.75} + assert switch.device_state_attributes == {"volts": 1.2, "amps": 2.8}