hass-core/tests/components/climate/test_melissa.py

"""Test for Melissa climate component."""
import unittest
from unittest.mock import Mock, patch
import json

from asynctest import mock

from homeassistant.components.climate import (
    melissa, SUPPORT_TARGET_TEMPERATURE, SUPPORT_OPERATION_MODE,
    SUPPORT_ON_OFF, SUPPORT_FAN_MODE, STATE_HEAT, STATE_FAN_ONLY, STATE_DRY,
    STATE_COOL, STATE_AUTO
)
from homeassistant.components.fan import SPEED_LOW, SPEED_MEDIUM, SPEED_HIGH
from homeassistant.components.melissa import DATA_MELISSA
from homeassistant.const import (
    TEMP_CELSIUS, STATE_ON, ATTR_TEMPERATURE, STATE_OFF, STATE_IDLE
)
from tests.common import get_test_home_assistant, load_fixture


class TestMelissa(unittest.TestCase):
    """Tests for Melissa climate."""

    def setUp(self):  # pylint: disable=invalid-name
        """Set up test variables."""
        self.hass = get_test_home_assistant()
        self._serial = '12345678'

        self.api = Mock()
        self.api.fetch_devices.return_value = json.loads(load_fixture(
            'melissa_fetch_devices.json'
        ))
        self.api.cur_settings.return_value = json.loads(load_fixture(
            'melissa_cur_settings.json'
        ))
        self.api.status.return_value = json.loads(load_fixture(
            'melissa_status.json'
        ))
        self.api.STATE_OFF = 0
        self.api.STATE_ON = 1
        self.api.STATE_IDLE = 2

        self.api.MODE_AUTO = 0
        self.api.MODE_FAN = 1
        self.api.MODE_HEAT = 2
        self.api.MODE_COOL = 3
        self.api.MODE_DRY = 4

        self.api.FAN_AUTO = 0
        self.api.FAN_LOW = 1
        self.api.FAN_MEDIUM = 2
        self.api.FAN_HIGH = 3

        self.api.STATE = 'state'
        self.api.MODE = 'mode'
        self.api.FAN = 'fan'
        self.api.TEMP = 'temp'

        device = self.api.fetch_devices()[self._serial]
        self.thermostat = melissa.MelissaClimate(
            self.api, device['serial_number'], device)
        self.thermostat.update()

    def tearDown(self):  # pylint: disable=invalid-name
        """Teardown this test class. Stop hass."""
        self.hass.stop()

    @patch("homeassistant.components.climate.melissa.MelissaClimate")
    def test_setup_platform(self, mocked_thermostat):
        """Test setup_platform."""
        device = self.api.fetch_devices()[self._serial]
        thermostat = mocked_thermostat(self.api, device['serial_number'],
                                       device)
        thermostats = [thermostat]

        self.hass.data[DATA_MELISSA] = self.api

        config = {}
        add_entities = Mock()
        discovery_info = {}

        melissa.setup_platform(self.hass, config, add_entities, discovery_info)
        add_entities.assert_called_once_with(thermostats)

    def test_get_name(self):
        """Test name property."""
        assert "Melissa 12345678" == self.thermostat.name

    def test_is_on(self):
        """Test name property."""
        assert self.thermostat.is_on
        self.thermostat._cur_settings = None
        assert not self.thermostat.is_on

    def test_current_fan_mode(self):
        """Test current_fan_mode property."""
        self.thermostat.update()
        assert SPEED_LOW == self.thermostat.current_fan_mode
        self.thermostat._cur_settings = None
        assert self.thermostat.current_fan_mode is None

    def test_current_temperature(self):
        """Test current temperature."""
        assert 27.4 == self.thermostat.current_temperature

    def test_current_temperature_no_data(self):
        """Test current temperature without data."""
        self.thermostat._data = None
        assert self.thermostat.current_temperature is None

    def test_target_temperature_step(self):
        """Test current target_temperature_step."""
        assert 1 == self.thermostat.target_temperature_step

    def test_current_operation(self):
        """Test current operation."""
        self.thermostat.update()
        assert self.thermostat.current_operation == STATE_HEAT
        self.thermostat._cur_settings = None
        assert self.thermostat.current_operation is None

    def test_operation_list(self):
        """Test the operation list."""
        assert [STATE_COOL, STATE_DRY, STATE_FAN_ONLY, STATE_HEAT] == \
            self.thermostat.operation_list

    def test_fan_list(self):
        """Test the fan list."""
        assert [STATE_AUTO, SPEED_HIGH, SPEED_LOW, SPEED_MEDIUM] == \
            self.thermostat.fan_list

    def test_target_temperature(self):
        """Test target temperature."""
        assert 16 == self.thermostat.target_temperature
        self.thermostat._cur_settings = None
        assert self.thermostat.target_temperature is None

    def test_state(self):
        """Test state."""
        assert STATE_ON == self.thermostat.state
        self.thermostat._cur_settings = None
        assert self.thermostat.state is None

    def test_temperature_unit(self):
        """Test temperature unit."""
        assert TEMP_CELSIUS == self.thermostat.temperature_unit

    def test_min_temp(self):
        """Test min temp."""
        assert 16 == self.thermostat.min_temp

    def test_max_temp(self):
        """Test max temp."""
        assert 30 == self.thermostat.max_temp

    def test_supported_features(self):
        """Test supported_features property."""
        features = (SUPPORT_TARGET_TEMPERATURE | SUPPORT_OPERATION_MODE |
                    SUPPORT_ON_OFF | SUPPORT_FAN_MODE)
        assert features == self.thermostat.supported_features

    def test_set_temperature(self):
        """Test set_temperature."""
        self.api.send.return_value = True
        self.thermostat.update()
        self.thermostat.set_temperature(**{ATTR_TEMPERATURE: 25})
        assert 25 == self.thermostat.target_temperature

    def test_fan_mode(self):
        """Test set_fan_mode."""
        self.api.send.return_value = True
        self.thermostat.set_fan_mode(SPEED_HIGH)
        assert SPEED_HIGH == self.thermostat.current_fan_mode

    def test_set_operation_mode(self):
        """Test set_operation_mode."""
        self.api.send.return_value = True
        self.thermostat.set_operation_mode(STATE_COOL)
        assert STATE_COOL == self.thermostat.current_operation

    def test_turn_on(self):
        """Test turn_on."""
        self.thermostat.turn_on()
        assert self.thermostat.state

    def test_turn_off(self):
        """Test turn_off."""
        self.thermostat.turn_off()
        assert STATE_OFF == self.thermostat.state

    def test_send(self):
        """Test send."""
        self.thermostat.update()
        assert self.thermostat.send(
            {'fan': self.api.FAN_MEDIUM})
        assert SPEED_MEDIUM == self.thermostat.current_fan_mode
        self.api.send.return_value = False
        self.thermostat._cur_settings = None
        assert not self.thermostat.send({
            'fan': self.api.FAN_LOW})
        assert SPEED_LOW != self.thermostat.current_fan_mode
        assert self.thermostat._cur_settings is None

    @mock.patch('homeassistant.components.climate.melissa._LOGGER.warning')
    def test_update(self, mocked_warning):
        """Test update."""
        self.thermostat.update()
        assert SPEED_LOW == self.thermostat.current_fan_mode
        assert STATE_HEAT == self.thermostat.current_operation
        self.thermostat._api.status.side_effect = KeyError('boom')
        self.thermostat.update()
        mocked_warning.assert_called_once_with(
            'Unable to update entity %s', self.thermostat.entity_id)

    def test_melissa_state_to_hass(self):
        """Test for translate melissa states to hass."""
        assert STATE_OFF == self.thermostat.melissa_state_to_hass(0)
        assert STATE_ON == self.thermostat.melissa_state_to_hass(1)
        assert STATE_IDLE == self.thermostat.melissa_state_to_hass(2)
        assert self.thermostat.melissa_state_to_hass(3) is None

    def test_melissa_op_to_hass(self):
        """Test for translate melissa operations to hass."""
        assert STATE_FAN_ONLY == self.thermostat.melissa_op_to_hass(1)
        assert STATE_HEAT == self.thermostat.melissa_op_to_hass(2)
        assert STATE_COOL == self.thermostat.melissa_op_to_hass(3)
        assert STATE_DRY == self.thermostat.melissa_op_to_hass(4)
        assert self.thermostat.melissa_op_to_hass(5) is None

    def test_melissa_fan_to_hass(self):
        """Test for translate melissa fan state to hass."""
        assert STATE_AUTO == self.thermostat.melissa_fan_to_hass(0)
        assert SPEED_LOW == self.thermostat.melissa_fan_to_hass(1)
        assert SPEED_MEDIUM == self.thermostat.melissa_fan_to_hass(2)
        assert SPEED_HIGH == self.thermostat.melissa_fan_to_hass(3)
        assert self.thermostat.melissa_fan_to_hass(4) is None

    @mock.patch('homeassistant.components.climate.melissa._LOGGER.warning')
    def test_hass_mode_to_melissa(self, mocked_warning):
        """Test for hass operations to melssa."""
        assert 1 == self.thermostat.hass_mode_to_melissa(STATE_FAN_ONLY)
        assert 2 == self.thermostat.hass_mode_to_melissa(STATE_HEAT)
        assert 3 == self.thermostat.hass_mode_to_melissa(STATE_COOL)
        assert 4 == self.thermostat.hass_mode_to_melissa(STATE_DRY)
        self.thermostat.hass_mode_to_melissa("test")
        mocked_warning.assert_called_once_with(
            "Melissa have no setting for %s mode", "test")

    @mock.patch('homeassistant.components.climate.melissa._LOGGER.warning')
    def test_hass_fan_to_melissa(self, mocked_warning):
        """Test for translate melissa states to hass."""
        assert 0 == self.thermostat.hass_fan_to_melissa(STATE_AUTO)
        assert 1 == self.thermostat.hass_fan_to_melissa(SPEED_LOW)
        assert 2 == self.thermostat.hass_fan_to_melissa(SPEED_MEDIUM)
        assert 3 == self.thermostat.hass_fan_to_melissa(SPEED_HIGH)
        self.thermostat.hass_fan_to_melissa("test")
        mocked_warning.assert_called_once_with(
            "Melissa have no setting for %s fan mode", "test")