def test_lock_value_changed(mock_openzwave): """Test value changed for Z-Wave lock.""" node = MockNode() values = MockEntityValues( primary=MockValue(data=None, node=node), access_control=None, alarm_type=None, alarm_level=None, ) device = zwave.get_device(node=node, values=values, node_config={}) assert not device.is_locked values.primary.data = True value_changed(values.primary) assert device.is_locked
def test_power_schemes(hass, mock_openzwave): """Test power attribute.""" mock_receivers = [] def mock_connect(receiver, signal, *args, **kwargs): if signal == MockNetwork.SIGNAL_VALUE_ADDED: mock_receivers.append(receiver) with patch('pydispatch.dispatcher.connect', new=mock_connect): yield from async_setup_component(hass, 'zwave', {'zwave': {}}) assert len(mock_receivers) == 1 node = MockNode(node_id=11, generic=const.GENERIC_TYPE_SWITCH_BINARY) switch = MockValue(data=True, node=node, index=12, instance=13, command_class=const.COMMAND_CLASS_SWITCH_BINARY, genre=const.GENRE_USER, type=const.TYPE_BOOL) hass.async_add_job(mock_receivers[0], node, switch) yield from hass.async_block_till_done() assert hass.states.get('switch.mock_node_mock_value').state == 'on' assert 'power_consumption' not in hass.states.get( 'switch.mock_node_mock_value').attributes def mock_update(self): self.hass.add_job(self.async_update_ha_state) with patch.object(zwave.node_entity.ZWaveBaseEntity, 'maybe_schedule_update', new=mock_update): power = MockValue(data=23.5, node=node, index=const.INDEX_SENSOR_MULTILEVEL_POWER, instance=13, command_class=const.COMMAND_CLASS_SENSOR_MULTILEVEL) hass.async_add_job(mock_receivers[0], node, power) yield from hass.async_block_till_done() assert hass.states.get( 'switch.mock_node_mock_value').attributes['power_consumption'] == 23.5
def setUp(self): """Initialize values for this testcase class.""" self.hass = get_test_home_assistant() self.hass.start() setup_component(self.hass, 'zwave', {'zwave': { 'new_entity_ids': True, }}) self.hass.block_till_done() self.node = MockNode() self.mock_schema = { const.DISC_COMPONENT: 'mock_component', const.DISC_VALUES: { const.DISC_PRIMARY: { const.DISC_COMMAND_CLASS: ['mock_primary_class'], }, 'secondary': { const.DISC_COMMAND_CLASS: ['mock_secondary_class'], }, 'optional': { const.DISC_COMMAND_CLASS: ['mock_optional_class'], const.DISC_OPTIONAL: True, } } } self.primary = MockValue(command_class='mock_primary_class', node=self.node) self.secondary = MockValue(command_class='mock_secondary_class', node=self.node) self.duplicate_secondary = MockValue( command_class='mock_secondary_class', node=self.node) self.optional = MockValue(command_class='mock_optional_class', node=self.node) self.no_match_value = MockValue(command_class='mock_bad_class', node=self.node) self.entity_id = 'mock_component.mock_node_mock_value' self.zwave_config = { 'zwave': { 'new_entity_ids': True, } } self.device_config = {self.entity_id: {}}
def test_track_message_workaround(mock_openzwave): """Test value changed for Z-Wave lock by alarm-clearing workaround.""" node = MockNode( manufacturer_id="003B", product_id="5044", stats={"lastReceivedMessage": [0] * 6}, ) values = MockEntityValues( primary=MockValue(data=True, node=node), access_control=None, alarm_type=None, alarm_level=None, ) # Here we simulate an RF lock. The first lock.get_device will call # update properties, simulating the first DoorLock report. We then trigger # a change, simulating the openzwave automatic refreshing behavior (which # is enabled for at least the lock that needs this workaround) node.stats["lastReceivedMessage"][5] = const.COMMAND_CLASS_DOOR_LOCK device = lock.get_device(node=node, values=values) value_changed(values.primary) assert device.is_locked assert device.extra_state_attributes[lock.ATTR_NOTIFICATION] == "RF Lock" # Simulate a keypad unlock. We trigger a value_changed() which simulates # the Alarm notification received from the lock. Then, we trigger # value_changed() to simulate the automatic refreshing behavior. values.access_control = MockValue(data=6, node=node) values.alarm_type = MockValue(data=19, node=node) values.alarm_level = MockValue(data=3, node=node) node.stats["lastReceivedMessage"][5] = const.COMMAND_CLASS_ALARM value_changed(values.access_control) node.stats["lastReceivedMessage"][5] = const.COMMAND_CLASS_DOOR_LOCK values.primary.data = False value_changed(values.primary) assert not device.is_locked assert (device.extra_state_attributes[lock.ATTR_LOCK_STATUS] == "Unlocked with Keypad by user 3") # Again, simulate an RF lock. device.lock() node.stats["lastReceivedMessage"][5] = const.COMMAND_CLASS_DOOR_LOCK value_changed(values.primary) assert device.is_locked assert device.extra_state_attributes[lock.ATTR_NOTIFICATION] == "RF Lock"
def test_multilevelsensor_value_changed_temp_celsius(hass, mock_openzwave): """Test value changed for Z-Wave multilevel sensor for temperature.""" hass.config.units.temperature_unit = homeassistant.const.TEMP_CELSIUS node = MockNode(command_classes=[ const.COMMAND_CLASS_SENSOR_MULTILEVEL, const.COMMAND_CLASS_METER, ]) value = MockValue(data=38.85555, units="C", node=node) values = MockEntityValues(primary=value) device = sensor.get_device(node=node, values=values, node_config={}) device.hass = hass assert device.state == 38.9 assert device.unit_of_measurement == homeassistant.const.TEMP_CELSIUS assert device.device_class == homeassistant.const.DEVICE_CLASS_TEMPERATURE value.data = 37.95555 value_changed(value) assert device.state == 38.0
def test_alarm_sensor_value_changed(hass, mock_openzwave): """Test value changed for Z-Wave sensor.""" node = MockNode(command_classes=[ const.COMMAND_CLASS_ALARM, const.COMMAND_CLASS_SENSOR_ALARM ]) value = MockValue(data=12.34, node=node, units=homeassistant.const.PERCENTAGE) values = MockEntityValues(primary=value) device = sensor.get_device(node=node, values=values, node_config={}) device.hass = hass assert device.state == 12.34 assert device.unit_of_measurement == homeassistant.const.PERCENTAGE assert device.device_class is None value.data = 45.67 value_changed(value) assert device.state == 45.67
async def test_set_protection_value_missing_class(hass, client): """Test setting protection value on node without protectionclass.""" network = hass.data[DATA_NETWORK] = MagicMock() node = MockNode(node_id=17) value = MockValue(value_id=123456, index=0, instance=1) network.nodes = {17: node} node.value = value node.set_protection.return_value = False resp = await client.post( "/api/zwave/protection/17", data=json.dumps({"value_id": "123456", "selection": "Protecton by Seuence"}), ) assert resp.status == 404 result = await resp.json() assert not node.set_protection.called assert result == {"message": "No protection commandclass on this node"}
def test_get_usercodes_no_genreuser(hass, client): """Test getting usercodes on node missing genre user.""" network = hass.data[DATA_NETWORK] = MagicMock() node = MockNode(node_id=18, command_classes=[const.COMMAND_CLASS_USER_CODE]) value = MockValue(index=0, command_class=const.COMMAND_CLASS_USER_CODE) value.genre = const.GENRE_SYSTEM value.label = "label" value.data = "1234" node.values = {0: value} network.nodes = {18: node} node.get_values.return_value = node.values resp = yield from client.get("/api/zwave/usercodes/18") assert resp.status == 200 result = yield from resp.json() assert result == {}
def device_mapping(hass, mock_openzwave): """Fixture to provide a precreated climate device. Test state mapping.""" node = MockNode() values = MockEntityValues( primary=MockValue(data=1, node=node), temperature=MockValue(data=5, node=node, units=None), mode=MockValue( data="Heat", data_items=["Off", "Cool", "Heat", "Full Power", "heat_cool"], node=node, ), fan_mode=MockValue(data="test2", data_items=[3, 4, 5], node=node), operating_state=MockValue(data="heating", node=node), fan_action=MockValue(data=7, node=node), ) device = climate.get_device(hass, node=node, values=values, node_config={}) yield device
async def test_get_usercodes(hass, client): """Test getting usercodes on node.""" network = hass.data[DATA_NETWORK] = MagicMock() node = MockNode(node_id=18, command_classes=[const.COMMAND_CLASS_USER_CODE]) value = MockValue(index=0, command_class=const.COMMAND_CLASS_USER_CODE) value.genre = const.GENRE_USER value.label = "label" value.data = "1234" node.values = {0: value} network.nodes = {18: node} node.get_values.return_value = node.values resp = await client.get("/api/zwave/usercodes/18") assert resp.status == 200 result = await resp.json() assert result == {"0": {"code": "1234", "label": "label", "length": 4}}
def test_lock_turn_on_and_off(mock_openzwave): """Test turning on a Z-Wave lock.""" node = MockNode() values = MockEntityValues( primary=MockValue(data=None, node=node), access_control=None, alarm_type=None, alarm_level=None, ) device = lock.get_device(node=node, values=values, node_config={}) assert not values.primary.data device.lock() assert values.primary.data device.unlock() assert not values.primary.data
def test_set_poll_intensity_disable(self): """Test zwave set_poll_intensity service, successful disable.""" node = MockNode(node_id=14) value = MockValue(index=12, value_id=123456, poll_intensity=4) node.values = {123456: value} self.zwave_network.nodes = {11: node} assert value.poll_intensity == 4 self.hass.services.call('zwave', 'set_poll_intensity', { const.ATTR_NODE_ID: 11, const.ATTR_VALUE_ID: 123456, const.ATTR_POLL_INTENSITY: 0, }) self.hass.block_till_done() disable_poll = value.disable_poll assert value.disable_poll.called assert len(disable_poll.mock_calls) == 2
def test_rgbcw_value_changed(mock_openzwave): """Test value changed for rgb lights.""" node = MockNode(command_classes=[const.COMMAND_CLASS_SWITCH_COLOR]) value = MockValue(data=0, node=node) color = MockValue(data="#0000000000", node=node) # Supports RGB, Cold White color_channels = MockValue(data=0x1E, node=node) values = MockLightValues(primary=value, color=color, color_channels=color_channels) device = light.get_device(node=node, values=values, node_config={}) assert device.hs_color == (0, 0) assert device.white_value == 0 color.data = "#c86400c800" value_changed(color) assert device.hs_color == (30, 100) assert device.white_value == 200
def test_dimmer_min_brightness(mock_openzwave): """Test turning on a dimmable Z-Wave light to its minimum brightness.""" node = MockNode() value = MockValue(data=0, node=node) values = MockLightValues(primary=value) device = zwave.get_device(node=node, values=values, node_config={}) assert not device.is_on device.turn_on(**{ATTR_BRIGHTNESS: 1}) assert device.is_on assert device.brightness == 1 device.turn_on(**{ATTR_BRIGHTNESS: 0}) assert device.is_on assert device.brightness == 0
def test_get_groups_nogroups(hass, test_client): """Test getting groupdata on node with no groups.""" app = mock_http_component_app(hass) ZWaveNodeGroupView().register(app.router) network = hass.data[ZWAVE_NETWORK] = MagicMock() node = MockNode(node_id=2) network.nodes = {2: node} client = yield from test_client(app) resp = yield from client.get('/api/zwave/groups/2') assert resp.status == 200 result = yield from resp.json() assert result == {}
def test_rgbcw_value_changed(mock_openzwave): """Test value changed for rgb lights.""" node = MockNode(command_classes=[const.COMMAND_CLASS_SWITCH_COLOR]) value = MockValue(data=0, node=node) color = MockValue(data='#0000000000', node=node) # Supports RGB, Cold White color_channels = MockValue(data=0x1e, node=node) values = MockLightValues(primary=value, color=color, color_channels=color_channels) device = zwave.get_device(node=node, values=values, node_config={}) assert device.rgb_color == [0, 0, 0] color.data = '#c86400c800' value_changed(color) assert device.rgb_color == [200, 150, 100]
def test_rgb_value_changed(mock_openzwave): """Test value changed for rgb lights.""" node = MockNode(command_classes=[const.COMMAND_CLASS_SWITCH_COLOR]) value = MockValue(data=0, node=node) color = MockValue(data='#0000000000', node=node) # Supports RGB only color_channels = MockValue(data=0x1c, node=node) values = MockLightValues(primary=value, color=color, color_channels=color_channels) device = zwave.get_device(node=node, values=values, node_config={}) assert device.hs_color == (0, 0) color.data = '#ffbf800000' value_changed(color) assert device.hs_color == (29.764, 49.804)
def test_garage_value_changed(hass, mock_openzwave): """Test position changed.""" node = MockNode() value = MockValue(data=False, node=node, command_class=const.COMMAND_CLASS_BARRIER_OPERATOR) values = MockEntityValues(primary=value, node=node) device = zwave.get_device(hass=hass, node=node, values=values, node_config={}) assert device.is_closed value.data = True value_changed(value) assert not device.is_closed
def test_node_discovery(hass, mock_openzwave): """Test discovery of a node.""" mock_receivers = [] def mock_connect(receiver, signal, *args, **kwargs): if signal == MockNetwork.SIGNAL_NODE_ADDED: mock_receivers.append(receiver) with patch('pydispatch.dispatcher.connect', new=mock_connect): yield from async_setup_component(hass, 'zwave', {'zwave': {}}) assert len(mock_receivers) == 1 node = MockNode(node_id=14) hass.async_add_job(mock_receivers[0], node) yield from hass.async_block_till_done() assert hass.states.get('zwave.mock_node_14').state is 'unknown'
def device_zxt_120(hass, mock_openzwave): """Fixture to provide a precreated climate device.""" node = MockNode(manufacturer_id='5254', product_id='8377') values = MockEntityValues( primary=MockValue(data=1, node=node), temperature=MockValue(data=5, node=node, units=None), mode=MockValue(data='test1', data_items=[0, 1, 2], node=node), fan_mode=MockValue(data='test2', data_items=[3, 4, 5], node=node), operating_state=MockValue(data=6, node=node), fan_state=MockValue(data=7, node=node), zxt_120_swing_mode=MockValue(data='test3', data_items=[6, 7, 8], node=node), ) device = climate.get_device(hass, node=node, values=values, node_config={}) yield device
def test_dimmer_transitions(mock_openzwave): """Test dimming transition on a dimmable Z-Wave light.""" node = MockNode() value = MockValue(data=0, node=node) duration = MockValue(data=0, node=node) values = MockLightValues(primary=value, dimming_duration=duration) device = light.get_device(node=node, values=values, node_config={}) assert device.color_mode == COLOR_MODE_BRIGHTNESS assert device.supported_features == SUPPORT_TRANSITION assert device.supported_color_modes == {COLOR_MODE_BRIGHTNESS} # Test turn_on # Factory Default device.turn_on() assert duration.data == 0xFF # Seconds transition device.turn_on(**{ATTR_TRANSITION: 45}) assert duration.data == 45 # Minutes transition device.turn_on(**{ATTR_TRANSITION: 245}) assert duration.data == 0x83 # Clipped transition device.turn_on(**{ATTR_TRANSITION: 10000}) assert duration.data == 0xFE # Test turn_off # Factory Default device.turn_off() assert duration.data == 0xFF # Seconds transition device.turn_off(**{ATTR_TRANSITION: 45}) assert duration.data == 45 # Minutes transition device.turn_off(**{ATTR_TRANSITION: 245}) assert duration.data == 0x83 # Clipped transition device.turn_off(**{ATTR_TRANSITION: 10000}) assert duration.data == 0xFE
def test_value_discovery_existing_entity(hass, mock_openzwave): """Test discovery of a node.""" mock_receivers = [] def mock_connect(receiver, signal, *args, **kwargs): if signal == MockNetwork.SIGNAL_VALUE_ADDED: mock_receivers.append(receiver) with patch('pydispatch.dispatcher.connect', new=mock_connect): yield from async_setup_component(hass, 'zwave', {'zwave': { 'new_entity_ids': True, }}) assert len(mock_receivers) == 1 node = MockNode(node_id=11, generic=const.GENERIC_TYPE_THERMOSTAT) setpoint = MockValue( data=22.0, node=node, index=12, instance=13, command_class=const.COMMAND_CLASS_THERMOSTAT_SETPOINT, genre=const.GENRE_USER, units='C') hass.async_add_job(mock_receivers[0], node, setpoint) yield from hass.async_block_till_done() assert hass.states.get('climate.mock_node_mock_value').attributes[ 'temperature'] == 22.0 assert hass.states.get('climate.mock_node_mock_value').attributes[ 'current_temperature'] is None def mock_update(self): self.hass.async_add_job(self.async_update_ha_state) with patch.object(zwave.node_entity.ZWaveBaseEntity, 'maybe_schedule_update', new=mock_update): temperature = MockValue( data=23.5, node=node, index=1, instance=13, command_class=const.COMMAND_CLASS_SENSOR_MULTILEVEL, genre=const.GENRE_USER, units='C') hass.async_add_job(mock_receivers[0], node, temperature) yield from hass.async_block_till_done() assert hass.states.get('climate.mock_node_mock_value').attributes[ 'temperature'] == 22.0 assert hass.states.get('climate.mock_node_mock_value').attributes[ 'current_temperature'] == 23.5
async def test_lock_set_usercode_service(hass, mock_openzwave): """Test the zwave lock set_usercode service.""" mock_network = hass.data[const.DATA_NETWORK] = MagicMock() node = MockNode(node_id=12) value0 = MockValue(data=" ", node=node, index=0) value1 = MockValue(data=" ", node=node, index=1) node.get_values.return_value = { value0.value_id: value0, value1.value_id: value1 } mock_network.nodes = {node.node_id: node} await setup_ozw(hass, mock_openzwave) await hass.async_block_till_done() await hass.services.async_call( lock.DOMAIN, lock.SERVICE_SET_USERCODE, { const.ATTR_NODE_ID: node.node_id, lock.ATTR_USERCODE: "1234", lock.ATTR_CODE_SLOT: 1, }, ) await hass.async_block_till_done() assert value1.data == "1234" mock_network.nodes = {node.node_id: node} await hass.services.async_call( lock.DOMAIN, lock.SERVICE_SET_USERCODE, { const.ATTR_NODE_ID: node.node_id, lock.ATTR_USERCODE: "123", lock.ATTR_CODE_SLOT: 1, }, ) await hass.async_block_till_done() assert value1.data == "1234"
def test_v2btze_value_changed(mock_openzwave): """Test value changed for v2btze Z-Wave lock.""" node = MockNode(manufacturer_id="010e", product_id="0002") values = MockEntityValues( primary=MockValue(data=None, node=node), v2btze_advanced=MockValue(data="Advanced", node=node), access_control=MockValue(data=19, node=node), alarm_type=None, alarm_level=None, ) device = lock.get_device(node=node, values=values, node_config={}) assert device._v2btze assert not device.is_locked values.access_control.data = 24 value_changed(values.primary) assert device.is_locked
def test_multilevelsensor_value_changed_other_units(mock_openzwave): """Test value changed for Z-Wave multilevel sensor for other units.""" node = MockNode( command_classes=[ const.COMMAND_CLASS_SENSOR_MULTILEVEL, const.COMMAND_CLASS_METER, ] ) value = MockValue( data=190.95555, units=homeassistant.const.ENERGY_KILO_WATT_HOUR, node=node ) values = MockEntityValues(primary=value) device = sensor.get_device(node=node, values=values, node_config={}) assert device.state == 190.96 assert device.unit_of_measurement == homeassistant.const.ENERGY_KILO_WATT_HOUR value.data = 197.95555 value_changed(value) assert device.state == 197.96
def test_set_poll_intensity_enable_failed(self): """Test zwave set_poll_intensity service, failed set.""" node = MockNode(node_id=14) value = MockValue(index=12, value_id=123456, poll_intensity=0) value.enable_poll.return_value = False node.values = {123456: value} self.zwave_network.nodes = {11: node} assert value.poll_intensity == 0 self.hass.services.call('zwave', 'set_poll_intensity', { const.ATTR_NODE_ID: 11, const.ATTR_VALUE_ID: 123456, const.ATTR_POLL_INTENSITY: 4, }) self.hass.block_till_done() enable_poll = value.enable_poll assert value.enable_poll.called assert len(enable_poll.mock_calls) == 1
def test_get_config_noconfig_node(hass, test_client): """Test getting config on node without config.""" app = mock_http_component_app(hass) ZWaveNodeConfigView().register(app.router) network = hass.data[ZWAVE_NETWORK] = MagicMock() node = MockNode(node_id=2) network.nodes = {2: node} node.get_values.return_value = node.values client = yield from test_client(app) resp = yield from client.get('/api/zwave/config/2') assert resp.status == 200 result = yield from resp.json() assert result == {}
def test_get_usercode_nousercode_node(hass, test_client): """Test getting usercodes on node without usercodes.""" app = mock_http_component_app(hass) ZWaveUserCodeView().register(app.router) network = hass.data[ZWAVE_NETWORK] = MagicMock() node = MockNode(node_id=18) network.nodes = {18: node} node.get_values.return_value = node.values client = yield from test_client(app) resp = yield from client.get('/api/zwave/usercodes/18') assert resp.status == 200 result = yield from resp.json() assert result == {}
def device_heat_eco(hass, mock_openzwave): """Fixture to provide a precreated climate device. heat/heat eco.""" node = MockNode() values = MockEntityValues( primary=MockValue( data=HVAC_MODE_HEAT, data_items=[HVAC_MODE_OFF, HVAC_MODE_HEAT, "heat econ"], node=node, ), setpoint_heating=MockValue(data=2, node=node), setpoint_eco_heating=MockValue(data=1, node=node), temperature=MockValue(data=5, node=node, units=None), fan_mode=MockValue(data="test2", data_items=[3, 4, 5], node=node), operating_state=MockValue(data="test4", node=node), fan_action=MockValue(data=7, node=node), ) device = climate.get_device(hass, node=node, values=values, node_config={}) yield device
def device_unknown(hass, mock_openzwave): """Fixture to provide a precreated climate device. Test state unknown.""" node = MockNode() values = MockEntityValues( primary=MockValue( data="Heat", data_items=["Off", "Cool", "Heat", "heat_cool", "Abcdefg"], node=node, ), setpoint_heating=MockValue(data=1, node=node), setpoint_cooling=MockValue(data=10, node=node), temperature=MockValue(data=5, node=node, units=None), fan_mode=MockValue(data="test2", data_items=[3, 4, 5], node=node), operating_state=MockValue(data="test4", node=node), fan_action=MockValue(data=7, node=node), ) device = climate.get_device(hass, node=node, values=values, node_config={}) yield device