jeans/core
jeans/core
1
0
Fork 0
mirror of https://github.com/home-assistant/core.git synced 2025-07-19 19:27:45 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fixes according to review from @MartinHjelmare Thank you. (#12171)

Browse Source
This commit is contained in:
kennedyshead 2018-02-06 21:27:35 +01:00 committed by Martin Hjelmare
parent cee57aab24
commit bd29cd2ba2
4 changed files with 68 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

81
homeassistant/components/climate/melissa.py
View File

@ -6,21 +6,32 @@ https://home-assistant.io/components/climate.melissa/
""" """
import logging import logging
from homeassistant.components.climate import ClimateDevice, \ from homeassistant.components.climate import (
SUPPORT_OPERATION_MODE, SUPPORT_TARGET_TEMPERATURE, SUPPORT_ON_OFF, \ ClimateDevice, SUPPORT_OPERATION_MODE, SUPPORT_TARGET_TEMPERATURE,
STATE_AUTO, STATE_HEAT, STATE_COOL, STATE_DRY, STATE_FAN_ONLY, \ SUPPORT_ON_OFF, STATE_AUTO, STATE_HEAT, STATE_COOL, STATE_DRY,
SUPPORT_FAN_MODE STATE_FAN_ONLY, SUPPORT_FAN_MODE
)
from homeassistant.components.fan import SPEED_LOW, SPEED_MEDIUM, SPEED_HIGH from homeassistant.components.fan import SPEED_LOW, SPEED_MEDIUM, SPEED_HIGH
from homeassistant.components.melissa import DATA_MELISSA, DOMAIN from homeassistant.components.melissa import DATA_MELISSA
from homeassistant.const import TEMP_CELSIUS, STATE_ON, STATE_OFF, \ from homeassistant.const import (
STATE_UNKNOWN, STATE_IDLE, ATTR_TEMPERATURE, PRECISION_WHOLE TEMP_CELSIUS, STATE_ON, STATE_OFF, STATE_IDLE, ATTR_TEMPERATURE,
PRECISION_WHOLE
)
DEPENDENCIES = [DOMAIN] DEPENDENCIES = ['melissa']
_LOGGER = logging.getLogger(__name__) _LOGGER = logging.getLogger(__name__)
SUPPORT_FLAGS = (SUPPORT_TARGET_TEMPERATURE | SUPPORT_OPERATION_MODE | SUPPORT_FLAGS = (SUPPORT_FAN_MODE | SUPPORT_OPERATION_MODE |
SUPPORT_ON_OFF | SUPPORT_FAN_MODE) SUPPORT_ON_OFF | SUPPORT_TARGET_TEMPERATURE)
OP_MODES = [
STATE_AUTO, STATE_COOL, STATE_DRY, STATE_FAN_ONLY, STATE_HEAT
]
FAN_MODES = [
STATE_AUTO, SPEED_HIGH, SPEED_LOW, SPEED_MEDIUM
]
def setup_platform(hass, config, add_devices, discovery_info=None): def setup_platform(hass, config, add_devices, discovery_info=None):
@ -60,9 +71,7 @@ class MelissaClimate(ClimateDevice):
if self._cur_settings is not None: if self._cur_settings is not None:
return self._cur_settings[self._api.STATE] in ( return self._cur_settings[self._api.STATE] in (
self._api.STATE_ON, self._api.STATE_IDLE) self._api.STATE_ON, self._api.STATE_IDLE)
else: return None
_LOGGER.info("Can't determine state of %s", self.entity_id)
return STATE_UNKNOWN
@property @property
def current_fan_mode(self): def current_fan_mode(self):
@ -70,20 +79,12 @@ class MelissaClimate(ClimateDevice):
if self._cur_settings is not None: if self._cur_settings is not None:
return self.melissa_fan_to_hass( return self.melissa_fan_to_hass(
self._cur_settings[self._api.FAN]) self._cur_settings[self._api.FAN])
else:
_LOGGER.info(
"Can't determine current fan mode for %s", self.entity_id)
return STATE_UNKNOWN
@property @property
def current_temperature(self): def current_temperature(self):
"""Return the current temperature.""" """Return the current temperature."""
if self._data: if self._data:
return self._data[self._api.TEMP] return self._data[self._api.TEMP]
else:
_LOGGER.info(
"Can't determine current temperature for %s", self.entity_id)
return None
@property @property
def target_temperature_step(self): def target_temperature_step(self):
@ -96,35 +97,22 @@ class MelissaClimate(ClimateDevice):
if self._cur_settings is not None: if self._cur_settings is not None:
return self.melissa_op_to_hass( return self.melissa_op_to_hass(
self._cur_settings[self._api.MODE]) self._cur_settings[self._api.MODE])
else:
_LOGGER.info(
"Can't determine current operation mode of %s", self.entity_id)
return STATE_UNKNOWN
@property @property
def operation_list(self): def operation_list(self):
"""Return the list of available operation modes.""" """Return the list of available operation modes."""
return [ return OP_MODES
STATE_AUTO, STATE_HEAT, STATE_COOL, STATE_DRY, STATE_FAN_ONLY
]
@property @property
def fan_list(self): def fan_list(self):
"""List of available fan modes.""" """List of available fan modes."""
return [ return FAN_MODES
STATE_AUTO, SPEED_LOW, SPEED_MEDIUM, SPEED_HIGH
]
@property @property
def target_temperature(self): def target_temperature(self):
"""Return the temperature we try to reach.""" """Return the temperature we try to reach."""
if self._cur_settings is not None: if self._cur_settings is not None:
return self._cur_settings[self._api.TEMP] return self._cur_settings[self._api.TEMP]
else:
_LOGGER.info(
"Can not determine current target temperature for %s",
self.entity_id)
return STATE_UNKNOWN
@property @property
def state(self): def state(self):
@ -132,9 +120,6 @@ class MelissaClimate(ClimateDevice):
if self._cur_settings is not None: if self._cur_settings is not None:
return self.melissa_state_to_hass( return self.melissa_state_to_hass(
self._cur_settings[self._api.STATE]) self._cur_settings[self._api.STATE])
else:
_LOGGER.info("Cant determine current state for %s", self.entity_id)
return STATE_UNKNOWN
@property @property
def temperature_unit(self): def temperature_unit(self):
@ -159,25 +144,25 @@ class MelissaClimate(ClimateDevice):
def set_temperature(self, **kwargs): def set_temperature(self, **kwargs):
"""Set new target temperature.""" """Set new target temperature."""
temp = kwargs.get(ATTR_TEMPERATURE) temp = kwargs.get(ATTR_TEMPERATURE)
return self.send({self._api.TEMP: temp}) self.send({self._api.TEMP: temp})
def set_fan_mode(self, fan): def set_fan_mode(self, fan):
"""Set fan mode.""" """Set fan mode."""
fan_mode = self.hass_fan_to_melissa(fan) fan_mode = self.hass_fan_to_melissa(fan)
return self.send({self._api.FAN: fan_mode}) self.send({self._api.FAN: fan_mode})
def set_operation_mode(self, operation_mode): def set_operation_mode(self, operation_mode):
"""Set operation mode.""" """Set operation mode."""
mode = self.hass_mode_to_melissa(operation_mode) mode = self.hass_mode_to_melissa(operation_mode)
return self.send({self._api.MODE: mode}) self.send({self._api.MODE: mode})
def turn_on(self): def turn_on(self):
"""Turn on device.""" """Turn on device."""
return self.send({self._api.STATE: self._api.STATE_ON}) self.send({self._api.STATE: self._api.STATE_ON})
def turn_off(self): def turn_off(self):
"""Turn off device.""" """Turn off device."""
return self.send({self._api.STATE: self._api.STATE_OFF}) self.send({self._api.STATE: self._api.STATE_OFF})
def send(self, value): def send(self, value):
"""Sending action to service.""" """Sending action to service."""
@ -201,7 +186,7 @@ class MelissaClimate(ClimateDevice):
)['controller']['_relation']['command_log'] )['controller']['_relation']['command_log']
except KeyError: except KeyError:
_LOGGER.warning( _LOGGER.warning(
'Unable to update component %s', self.entity_id) 'Unable to update entity %s', self.entity_id)
def melissa_state_to_hass(self, state): def melissa_state_to_hass(self, state):
"""Translate Melissa states to hass states.""" """Translate Melissa states to hass states."""
@ -212,7 +197,7 @@ class MelissaClimate(ClimateDevice):
elif state == self._api.STATE_IDLE: elif state == self._api.STATE_IDLE:
return STATE_IDLE return STATE_IDLE
else: else:
return STATE_UNKNOWN return None
def melissa_op_to_hass(self, mode): def melissa_op_to_hass(self, mode):
"""Translate Melissa modes to hass states.""" """Translate Melissa modes to hass states."""
@ -229,7 +214,7 @@ class MelissaClimate(ClimateDevice):
else: else:
_LOGGER.warning( _LOGGER.warning(
"Operation mode %s could not be mapped to hass", mode) "Operation mode %s could not be mapped to hass", mode)
return STATE_UNKNOWN return None
def melissa_fan_to_hass(self, fan): def melissa_fan_to_hass(self, fan):
"""Translate Melissa fan modes to hass modes.""" """Translate Melissa fan modes to hass modes."""
@ -243,7 +228,7 @@ class MelissaClimate(ClimateDevice):
return SPEED_HIGH return SPEED_HIGH
else: else:
_LOGGER.warning("Fan mode %s could not be mapped to hass", fan) _LOGGER.warning("Fan mode %s could not be mapped to hass", fan)
return STATE_UNKNOWN return None
def hass_mode_to_melissa(self, mode): def hass_mode_to_melissa(self, mode):
"""Translate hass states to melissa modes.""" """Translate hass states to melissa modes."""

8
homeassistant/components/sensor/melissa.py
View File

@ -6,11 +6,11 @@ https://home-assistant.io/components/sensor.melissa/
""" """
import logging import logging
from homeassistant.components.melissa import DOMAIN, DATA_MELISSA from homeassistant.components.melissa import DATA_MELISSA
from homeassistant.const import TEMP_CELSIUS, STATE_UNKNOWN from homeassistant.const import TEMP_CELSIUS
from homeassistant.helpers.entity import Entity from homeassistant.helpers.entity import Entity
DEPENDENCIES = [DOMAIN] DEPENDENCIES = ['melissa']
_LOGGER = logging.getLogger(__name__) _LOGGER = logging.getLogger(__name__)
@ -35,7 +35,7 @@ class MelissaSensor(Entity):
def __init__(self, device, api): def __init__(self, device, api):
"""Initialize the sensor.""" """Initialize the sensor."""
self._api = api self._api = api
self._state = STATE_UNKNOWN self._state = None
self._name = '{0} {1}'.format( self._name = '{0} {1}'.format(
device['name'], device['name'],
self._type self._type

53
tests/components/climate/test_melissa.py
View File

@ -5,14 +5,16 @@ import json
from asynctest import mock from asynctest import mock
from homeassistant.components.climate import melissa, \ from homeassistant.components.climate import (
SUPPORT_TARGET_TEMPERATURE, SUPPORT_OPERATION_MODE, SUPPORT_ON_OFF, \ melissa, SUPPORT_TARGET_TEMPERATURE, SUPPORT_OPERATION_MODE,
SUPPORT_FAN_MODE, STATE_HEAT, STATE_FAN_ONLY, STATE_DRY, STATE_COOL, \ SUPPORT_ON_OFF, SUPPORT_FAN_MODE, STATE_HEAT, STATE_FAN_ONLY, STATE_DRY,
STATE_AUTO STATE_COOL, STATE_AUTO
)
from homeassistant.components.fan import SPEED_LOW, SPEED_MEDIUM, SPEED_HIGH from homeassistant.components.fan import SPEED_LOW, SPEED_MEDIUM, SPEED_HIGH
from homeassistant.components.melissa import DATA_MELISSA from homeassistant.components.melissa import DATA_MELISSA
from homeassistant.const import TEMP_CELSIUS, STATE_ON, ATTR_TEMPERATURE, \ from homeassistant.const import (
STATE_OFF, STATE_IDLE, STATE_UNKNOWN TEMP_CELSIUS, STATE_ON, ATTR_TEMPERATURE, STATE_OFF, STATE_IDLE
)
from tests.common import get_test_home_assistant, load_fixture from tests.common import get_test_home_assistant, load_fixture
@ -86,16 +88,16 @@ class TestMelissa(unittest.TestCase):
def test_is_on(self): def test_is_on(self):
"""Test name property.""" """Test name property."""
self.assertEqual(self.thermostat.is_on, True) self.assertTrue(self.thermostat.is_on)
self.thermostat._cur_settings = None self.thermostat._cur_settings = None
self.assertEqual(STATE_UNKNOWN, self.thermostat.is_on) self.assertFalse(self.thermostat.is_on)
def test_current_fan_mode(self): def test_current_fan_mode(self):
"""Test current_fan_mode property.""" """Test current_fan_mode property."""
self.thermostat.update() self.thermostat.update()
self.assertEqual(SPEED_LOW, self.thermostat.current_fan_mode) self.assertEqual(SPEED_LOW, self.thermostat.current_fan_mode)
self.thermostat._cur_settings = None self.thermostat._cur_settings = None
self.assertEqual(STATE_UNKNOWN, self.thermostat.current_fan_mode) self.assertEqual(None, self.thermostat.current_fan_mode)
def test_current_temperature(self): def test_current_temperature(self):
"""Test current temperature.""" """Test current temperature."""
@ -115,19 +117,19 @@ class TestMelissa(unittest.TestCase):
self.thermostat.update() self.thermostat.update()
self.assertEqual(self.thermostat.current_operation, STATE_HEAT) self.assertEqual(self.thermostat.current_operation, STATE_HEAT)
self.thermostat._cur_settings = None self.thermostat._cur_settings = None
self.assertEqual(STATE_UNKNOWN, self.thermostat.current_operation) self.assertEqual(None, self.thermostat.current_operation)
def test_operation_list(self): def test_operation_list(self):
"""Test the operation list.""" """Test the operation list."""
self.assertEqual( self.assertEqual(
[STATE_AUTO, STATE_HEAT, STATE_COOL, STATE_DRY, STATE_FAN_ONLY], [STATE_AUTO, STATE_COOL, STATE_DRY, STATE_FAN_ONLY, STATE_HEAT],
self.thermostat.operation_list self.thermostat.operation_list
) )
def test_fan_list(self): def test_fan_list(self):
"""Test the fan list.""" """Test the fan list."""
self.assertEqual( self.assertEqual(
[STATE_AUTO, SPEED_LOW, SPEED_MEDIUM, SPEED_HIGH], [STATE_AUTO, SPEED_HIGH, SPEED_LOW, SPEED_MEDIUM],
self.thermostat.fan_list self.thermostat.fan_list
) )
@ -135,13 +137,13 @@ class TestMelissa(unittest.TestCase):
"""Test target temperature.""" """Test target temperature."""
self.assertEqual(16, self.thermostat.target_temperature) self.assertEqual(16, self.thermostat.target_temperature)
self.thermostat._cur_settings = None self.thermostat._cur_settings = None
self.assertEqual(STATE_UNKNOWN, self.thermostat.target_temperature) self.assertEqual(None, self.thermostat.target_temperature)
def test_state(self): def test_state(self):
"""Test state.""" """Test state."""
self.assertEqual(STATE_ON, self.thermostat.state) self.assertEqual(STATE_ON, self.thermostat.state)
self.thermostat._cur_settings = None self.thermostat._cur_settings = None
self.assertEqual(STATE_UNKNOWN, self.thermostat.state) self.assertEqual(None, self.thermostat.state)
def test_temperature_unit(self): def test_temperature_unit(self):
"""Test temperature unit.""" """Test temperature unit."""
@ -165,29 +167,30 @@ class TestMelissa(unittest.TestCase):
"""Test set_temperature.""" """Test set_temperature."""
self.api.send.return_value = True self.api.send.return_value = True
self.thermostat.update() self.thermostat.update()
self.assertTrue(self.thermostat.set_temperature( self.thermostat.set_temperature(**{ATTR_TEMPERATURE: 25})
**{ATTR_TEMPERATURE: 25}))
self.assertEqual(25, self.thermostat.target_temperature) self.assertEqual(25, self.thermostat.target_temperature)
def test_fan_mode(self): def test_fan_mode(self):
"""Test set_fan_mode.""" """Test set_fan_mode."""
self.api.send.return_value = True self.api.send.return_value = True
self.assertTrue(self.thermostat.set_fan_mode(SPEED_LOW)) self.thermostat.set_fan_mode(SPEED_HIGH)
self.assertEqual(SPEED_LOW, self.thermostat.current_fan_mode) self.assertEqual(SPEED_HIGH, self.thermostat.current_fan_mode)
def test_set_operation_mode(self): def test_set_operation_mode(self):
"""Test set_operation_mode.""" """Test set_operation_mode."""
self.api.send.return_value = True self.api.send.return_value = True
self.assertTrue(self.thermostat.set_operation_mode(STATE_COOL)) self.thermostat.set_operation_mode(STATE_COOL)
self.assertEqual(STATE_COOL, self.thermostat.current_operation) self.assertEqual(STATE_COOL, self.thermostat.current_operation)
def test_turn_on(self): def test_turn_on(self):
"""Test turn_on.""" """Test turn_on."""
self.assertTrue(self.thermostat.turn_on()) self.thermostat.turn_on()
self.assertTrue(self.thermostat.state)
def test_turn_off(self): def test_turn_off(self):
"""Test turn_off.""" """Test turn_off."""
self.assertTrue(self.thermostat.turn_off()) self.thermostat.turn_off()
self.assertEqual(STATE_OFF, self.thermostat.state)
def test_send(self): def test_send(self):
"""Test send.""" """Test send."""
@ -211,14 +214,14 @@ class TestMelissa(unittest.TestCase):
self.thermostat._api.status.side_effect = KeyError('boom') self.thermostat._api.status.side_effect = KeyError('boom')
self.thermostat.update() self.thermostat.update()
mocked_warning.assert_called_once_with( mocked_warning.assert_called_once_with(
'Unable to update component %s', self.thermostat.entity_id) 'Unable to update entity %s', self.thermostat.entity_id)
def test_melissa_state_to_hass(self): def test_melissa_state_to_hass(self):
"""Test for translate melissa states to hass.""" """Test for translate melissa states to hass."""
self.assertEqual(STATE_OFF, self.thermostat.melissa_state_to_hass(0)) self.assertEqual(STATE_OFF, self.thermostat.melissa_state_to_hass(0))
self.assertEqual(STATE_ON, self.thermostat.melissa_state_to_hass(1)) self.assertEqual(STATE_ON, self.thermostat.melissa_state_to_hass(1))
self.assertEqual(STATE_IDLE, self.thermostat.melissa_state_to_hass(2)) self.assertEqual(STATE_IDLE, self.thermostat.melissa_state_to_hass(2))
self.assertEqual(STATE_UNKNOWN, self.assertEqual(None,
self.thermostat.melissa_state_to_hass(3)) self.thermostat.melissa_state_to_hass(3))
def test_melissa_op_to_hass(self): def test_melissa_op_to_hass(self):
@ -229,7 +232,7 @@ class TestMelissa(unittest.TestCase):
self.assertEqual(STATE_COOL, self.thermostat.melissa_op_to_hass(3)) self.assertEqual(STATE_COOL, self.thermostat.melissa_op_to_hass(3))
self.assertEqual(STATE_DRY, self.thermostat.melissa_op_to_hass(4)) self.assertEqual(STATE_DRY, self.thermostat.melissa_op_to_hass(4))
self.assertEqual( self.assertEqual(
STATE_UNKNOWN, self.thermostat.melissa_op_to_hass(5)) None, self.thermostat.melissa_op_to_hass(5))
def test_melissa_fan_to_hass(self): def test_melissa_fan_to_hass(self):
"""Test for translate melissa fan state to hass.""" """Test for translate melissa fan state to hass."""
@ -237,7 +240,7 @@ class TestMelissa(unittest.TestCase):
self.assertEqual(SPEED_LOW, self.thermostat.melissa_fan_to_hass(1)) self.assertEqual(SPEED_LOW, self.thermostat.melissa_fan_to_hass(1))
self.assertEqual(SPEED_MEDIUM, self.thermostat.melissa_fan_to_hass(2)) self.assertEqual(SPEED_MEDIUM, self.thermostat.melissa_fan_to_hass(2))
self.assertEqual(SPEED_HIGH, self.thermostat.melissa_fan_to_hass(3)) self.assertEqual(SPEED_HIGH, self.thermostat.melissa_fan_to_hass(3))
self.assertEqual(STATE_UNKNOWN, self.thermostat.melissa_fan_to_hass(4)) self.assertEqual(None, self.thermostat.melissa_fan_to_hass(4))
@mock.patch('homeassistant.components.climate.melissa._LOGGER.warning') @mock.patch('homeassistant.components.climate.melissa._LOGGER.warning')
def test_hass_mode_to_melissa(self, mocked_warning): def test_hass_mode_to_melissa(self, mocked_warning):

6
tests/components/sensor/test_melissa.py
View File

@ -7,7 +7,7 @@ from homeassistant.components.melissa import DATA_MELISSA
from homeassistant.components.sensor import melissa from homeassistant.components.sensor import melissa
from homeassistant.components.sensor.melissa import MelissaTemperatureSensor, \ from homeassistant.components.sensor.melissa import MelissaTemperatureSensor, \
MelissaHumiditySensor MelissaHumiditySensor
from homeassistant.const import TEMP_CELSIUS, STATE_UNKNOWN from homeassistant.const import TEMP_CELSIUS
from tests.common import get_test_home_assistant, load_fixture from tests.common import get_test_home_assistant, load_fixture
@ -83,7 +83,7 @@ class TestMelissa(unittest.TestCase):
"""Test for faulty update.""" """Test for faulty update."""
self.temp._api.status.return_value = {} self.temp._api.status.return_value = {}
self.temp.update() self.temp.update()
self.assertEqual(STATE_UNKNOWN, self.temp.state) self.assertEqual(None, self.temp.state)
self.hum._api.status.return_value = {} self.hum._api.status.return_value = {}
self.hum.update() self.hum.update()
self.assertEqual(STATE_UNKNOWN, self.hum.state) self.assertEqual(None, self.hum.state)