async def test_dynalite_error_message(mock_gateway):
"""Test when a message arrives with the wrong checksum."""
[device] = mock_gateway.configure_dyn_dev(
{
dyn_const.CONF_ACTIVE: False,
dyn_const.CONF_AREA: {
"1": {
dyn_const.CONF_CHANNEL: {
"1": {}
}
}
},
dyn_const.CONF_PRESET: {},
}, )
assert await mock_gateway.async_setup_dyn_dev()
await mock_gateway.check_single_update(None)
assert not device.is_on
packet = DynetPacket.set_channel_level_packet(1, 1, 1.0, 0.5)
message = packet.msg
message[7] += 1
await mock_gateway.receive_message(message)
assert not device.is_on
packet = DynetPacket.set_channel_level_packet(1, 1, 1.0, 0.5)
await mock_gateway.receive(packet)
await mock_gateway.check_single_update(device)
await mock_gateway.check_notifications(
[packet_notification(packet.raw_msg)])
assert device.is_on
async def test_channel_switch(mock_gateway):
"""Test a Dynalite channel that is a switch."""
name = "NAME"
[device] = mock_gateway.configure_dyn_dev({
dyn_const.CONF_ACTIVE: False,
dyn_const.CONF_AREA: {
"1": {
dyn_const.CONF_NAME: name,
dyn_const.CONF_NO_DEFAULT: True,
dyn_const.CONF_CHANNEL: {
"1": {
dyn_const.CONF_FADE: 0.5,
dyn_const.CONF_CHANNEL_TYPE: "switch",
}
},
}
},
})
assert await mock_gateway.async_setup_dyn_dev()
assert device.category == "switch"
assert device.name == f"{name} Channel 1"
assert device.unique_id == "dynalite_area_1_channel_1"
assert device.available
assert device.area_name == name
assert device.get_master_area == name
await device.async_turn_on()
await mock_gateway.check_single_write(
DynetPacket.set_channel_level_packet(1, 1, 1.0, 0.5))
assert device.is_on
await device.async_turn_off()
await mock_gateway.check_single_write(
DynetPacket.set_channel_level_packet(1, 1, 0.0, 0.5))
assert not device.is_on
async def test_dynalite_two_messages(mock_gateway):
"""Test when two messages arrive together."""
devices = mock_gateway.configure_dyn_dev(
{
dyn_const.CONF_ACTIVE: False,
dyn_const.CONF_AREA: {
"1": {
dyn_const.CONF_CHANNEL: {
"1": {},
"2": {}
}
}
},
dyn_const.CONF_PRESET: {},
},
2,
)
assert await mock_gateway.async_setup_dyn_dev()
await mock_gateway.check_single_update(None)
for device in devices:
assert not device.is_on
packet1 = DynetPacket.set_channel_level_packet(1, 1, 1.0, 0.5)
packet2 = DynetPacket.set_channel_level_packet(1, 2, 1.0, 0.5)
await mock_gateway.receive_message(packet1.msg + packet2.msg)
await mock_gateway.check_updates(devices)
await mock_gateway.check_notifications([
packet_notification(packet1.raw_msg),
packet_notification(packet2.raw_msg)
])
for device in devices:
assert device.is_on
def test_channel_fade_limit():
"""Test that set_channel_level has a limit at 0xFF (5.1 seconds)."""
packet1 = DynetPacket.set_channel_level_packet(1, 1, 1, 100)
packet2 = DynetPacket.set_channel_level_packet(1, 1, 1, 5.101)
packet3 = DynetPacket.set_channel_level_packet(1, 1, 1, 5.05)
assert packet1.msg == packet2.msg
assert packet1.msg != packet3.msg
async def test_light(mock_gateway):
"""Test a Dynalite channel that is a light."""
name = "NAME"
channel_name = "CHANNEL"
[device] = mock_gateway.configure_dyn_dev({
dyn_const.CONF_ACTIVE: False,
dyn_const.CONF_AREA: {
"1": {
dyn_const.CONF_NAME: name,
dyn_const.CONF_NO_DEFAULT: True,
dyn_const.CONF_CHANNEL: {
"1": {
dyn_const.CONF_NAME: channel_name,
dyn_const.CONF_FADE: 0.5,
}
},
}
},
})
assert await mock_gateway.async_setup_dyn_dev()
assert device.category == "light"
assert device.name == f"{name} {channel_name}"
assert device.unique_id == "dynalite_area_1_channel_1"
assert device.available
assert device.area_name == name
assert device.get_master_area == name
await device.async_turn_on()
await mock_gateway.check_single_write(
DynetPacket.set_channel_level_packet(1, 1, 1.0, 0.5))
assert device.brightness == 255
await device.async_turn_on(brightness=51)
await mock_gateway.check_single_write(
DynetPacket.set_channel_level_packet(1, 1, 0.2, 0.5))
assert device.brightness == 51
await device.async_turn_off()
await mock_gateway.check_single_write(
DynetPacket.set_channel_level_packet(1, 1, 0, 0.5))
assert device.brightness == 0
# Now send commands
await mock_gateway.receive(
DynetPacket.set_channel_level_packet(1, 1, 1.0, 0.5))
assert device.brightness == 255
assert device.is_on
await mock_gateway.receive(
DynetPacket.set_channel_level_packet(1, 1, 0.2, 0.5))
assert device.brightness == 51
assert device.is_on
await mock_gateway.receive(
DynetPacket.report_channel_level_packet(1, 1, 0, 0))
assert device.brightness == 0
assert not device.is_on
async def test_dynalite_split_message(mock_gateway):
"""Test when a received message is split into two packets."""
[device] = mock_gateway.configure_dyn_dev(
{
dyn_const.CONF_ACTIVE: False,
dyn_const.CONF_AREA: {
"1": {
dyn_const.CONF_CHANNEL: {
"1": {}
}
}
},
dyn_const.CONF_PRESET: {},
}, )
assert await mock_gateway.async_setup_dyn_dev()
await mock_gateway.check_single_update(None)
assert not device.is_on
packet = DynetPacket.set_channel_level_packet(1, 1, 1.0, 0.5)
msg1 = packet.msg[0:5]
msg2 = packet.msg[5:8]
await mock_gateway.receive_message(msg1)
await mock_gateway.receive_message(msg2)
await mock_gateway.check_single_update(device)
await mock_gateway.check_notifications(
[packet_notification(packet.raw_msg)])
assert device.is_on
async def test_dynalite_devices_default_fade(mock_gateway):
"""Test that default fade works correctly."""
[channel_device, preset_device] = mock_gateway.configure_dyn_dev(
{
dyn_const.CONF_ACTIVE: False,
dyn_const.CONF_DEFAULT: {
dyn_const.CONF_FADE: 0.5
},
dyn_const.CONF_AREA: {
"1": {
dyn_const.CONF_CHANNEL: {
"1": {}
}
}
},
dyn_const.CONF_PRESET: {
"1": {}
},
},
2,
)
assert await mock_gateway.async_setup_dyn_dev()
await mock_gateway.check_writes([])
await channel_device.async_turn_on()
await mock_gateway.check_single_write(
DynetPacket.set_channel_level_packet(1, 1, 1.0, 0.5))
await preset_device.async_turn_on()
await mock_gateway.check_single_write(
DynetPacket.select_area_preset_packet(1, 1, 0.5))
async def test_dynalite_unknown_message(mock_gateway):
"""Test when a message arrives that we don't know."""
[device] = mock_gateway.configure_dyn_dev(
{
dyn_const.CONF_ACTIVE: False,
dyn_const.CONF_AREA: {
"1": {
dyn_const.CONF_CHANNEL: {
"1": {}
}
}
},
dyn_const.CONF_PRESET: {},
}, )
assert await mock_gateway.async_setup_dyn_dev()
await mock_gateway.check_single_update(None)
assert not device.is_on
packet = DynetPacket(area=1, command=200, data=[0, 0, 0])
await mock_gateway.receive(packet)
await mock_gateway.check_notifications(
[packet_notification(packet.raw_msg)])
assert not device.is_on
packet = DynetPacket.set_channel_level_packet(1, 1, 1.0, 0.5)
await mock_gateway.receive(packet)
await mock_gateway.check_single_update(device)
await mock_gateway.check_notifications(
[packet_notification(packet.raw_msg)])
assert device.is_on
async def test_dynalite_devices_auto_discover_template(mock_gateway):
"""Test auto discover ON when running into a template that shouldn't show the device."""
config = {
dyn_const.CONF_ACTIVE: False,
dyn_const.CONF_AUTO_DISCOVER: True,
dyn_const.CONF_AREA: {
1: {
dyn_const.CONF_TEMPLATE: dyn_const.CONF_ROOM
},
2: {
dyn_const.CONF_TEMPLATE: dyn_const.CONF_TIME_COVER
},
},
}
mock_gateway.configure_dyn_dev(config, 2)
assert await mock_gateway.async_setup_dyn_dev()
await mock_gateway.check_single_update(None)
func = mock_gateway.new_dev_func
func.reset_mock()
packet_to_send = DynetPacket.report_area_preset_packet(1, 2)
await mock_gateway.receive(packet_to_send)
await mock_gateway.check_notifications([
packet_notification(packet_to_send.raw_msg),
preset_notification(1, 2)
])
func.assert_not_called()
packet_to_send = DynetPacket.set_channel_level_packet(2, 3, 0, 0)
await mock_gateway.receive(packet_to_send)
await mock_gateway.check_notifications(
[packet_notification(packet_to_send.raw_msg)])
func.assert_not_called()
async def test_dynalite_devices_auto_discover_on(mock_gateway):
"""Test autodiscover ON."""
config = {
dyn_const.CONF_ACTIVE: False,
dyn_const.CONF_AUTO_DISCOVER: True,
dyn_const.CONF_AREA: {},
}
mock_gateway.configure_dyn_dev(config, 0)
assert await mock_gateway.async_setup_dyn_dev()
await mock_gateway.check_single_update(None)
func = mock_gateway.new_dev_func
func.reset_mock()
packet_to_send = DynetPacket.report_area_preset_packet(1, 1)
await mock_gateway.receive(packet_to_send)
await mock_gateway.check_notifications([
packet_notification(packet_to_send.raw_msg),
preset_notification(1, 1)
])
func.assert_called_once()
devices = func.mock_calls[0][1][0]
assert len(devices) == 1
assert devices[0].unique_id == "dynalite_area_1_preset_1"
await mock_gateway.check_single_update(devices[0])
func.reset_mock()
packet_to_send = DynetPacket.set_channel_level_packet(2, 3, 0, 0)
await mock_gateway.receive(packet_to_send)
await mock_gateway.check_notifications(
[packet_notification(packet_to_send.raw_msg)])
func.assert_called_once()
devices = func.mock_calls[0][1][0]
assert len(devices) == 1
assert devices[0].unique_id == "dynalite_area_2_channel_3"
await mock_gateway.check_single_update(devices[0])
async def test_dynalite_device_message(mock_gateway):
"""Test when a DEVICE message arrives."""
[device] = mock_gateway.configure_dyn_dev(
{
dyn_const.CONF_ACTIVE: False,
dyn_const.CONF_AREA: {
"1": {
dyn_const.CONF_CHANNEL: {
"1": {}
}
}
},
dyn_const.CONF_PRESET: {},
}, )
assert await mock_gateway.async_setup_dyn_dev()
await mock_gateway.check_single_update(None)
assert not device.is_on
# putting a device message + a device-on message half-way.
# will verify that it will first read the device message and then ignore other
packet = DynetPacket.set_channel_level_packet(1, 1, 1.0, 0.5)
int_message = [SyncType.DEVICE.value, 65, 66] + packet.raw_msg
message = bytearray(int_message)
await mock_gateway.receive_message(message)
await mock_gateway.check_notifications(
[packet_notification(int_message[:8])])
assert not device.is_on
await mock_gateway.receive(packet)
await mock_gateway.check_single_update(device)
await mock_gateway.check_notifications(
[packet_notification(packet.raw_msg)])
assert device.is_on
async def test_dynalite_shift_message(mock_gateway):
"""Test when a received message arrives out of the normal 8bit pattern."""
[device] = mock_gateway.configure_dyn_dev(
{
dyn_const.CONF_ACTIVE: False,
dyn_const.CONF_AREA: {"1": {dyn_const.CONF_CHANNEL: {"1": {}}}},
dyn_const.CONF_PRESET: {},
},
)
assert await mock_gateway.async_setup_dyn_dev()
assert not device.is_on
packet = DynetPacket.set_channel_level_packet(1, 1, 1.0, 0.5)
message = bytearray([3, 7, 12]) + packet.msg
await mock_gateway.receive_message(message)
assert device.is_on
async def test_dynalite_unhandled_message(mock_gateway):
"""Test when a message arrives that we know but don't handle."""
[device] = mock_gateway.configure_dyn_dev(
{
dyn_const.CONF_ACTIVE: False,
dyn_const.CONF_AREA: {"1": {dyn_const.CONF_CHANNEL: {"1": {}}}},
dyn_const.CONF_PRESET: {},
},
)
assert await mock_gateway.async_setup_dyn_dev()
assert not device.is_on
packet = DynetPacket(area=1, command=45, data=[0, 0, 0])
await mock_gateway.receive(packet)
assert not device.is_on
await mock_gateway.receive(DynetPacket.set_channel_level_packet(1, 1, 1.0, 0.5))
assert device.is_on
async def test_dynalite_devices_auto_discover_off(mock_gateway):
"""Test autodiscover OFF."""
config = {
dyn_const.CONF_ACTIVE: False,
dyn_const.CONF_AUTO_DISCOVER: False,
dyn_const.CONF_AREA: {},
}
mock_gateway.configure_dyn_dev(config, 0)
assert await mock_gateway.async_setup_dyn_dev()
func = mock_gateway.new_dev_func
func.reset_mock()
await mock_gateway.receive(DynetPacket.report_area_preset_packet(1, 1))
func.assert_not_called()
await mock_gateway.receive(DynetPacket.set_channel_level_packet(
2, 3, 0, 0))
func.assert_not_called()
async def test_dynalite_device_message(mock_gateway):
"""Test when a DEVICE message arrives."""
[device] = mock_gateway.configure_dyn_dev(
{
dyn_const.CONF_ACTIVE: False,
dyn_const.CONF_AREA: {"1": {dyn_const.CONF_CHANNEL: {"1": {}}}},
dyn_const.CONF_PRESET: {},
},
)
assert await mock_gateway.async_setup_dyn_dev()
assert not device.is_on
# putting a device message + a device-on message half-way.
# will verify that it will first read the device message and then ignore other
packet = DynetPacket.set_channel_level_packet(1, 1, 1.0, 0.5)
message = bytearray([SyncType.DEVICE.value, 7, 12]) + packet.msg
await mock_gateway.receive_message(message)
assert not device.is_on
await mock_gateway.receive(packet)
assert device.is_on
async def test_dynalite_devices_auto_discover_on(mock_gateway):
"""Test autodiscover ON."""
config = {
dyn_const.CONF_ACTIVE: False,
dyn_const.CONF_AUTO_DISCOVER: True,
dyn_const.CONF_AREA: {},
}
mock_gateway.configure_dyn_dev(config, 0)
assert await mock_gateway.async_setup_dyn_dev()
func = mock_gateway.new_dev_func
func.reset_mock()
await mock_gateway.receive(DynetPacket.report_area_preset_packet(1, 1))
func.assert_called_once()
devices = func.mock_calls[0][1][0]
assert len(devices) == 1
assert devices[0].unique_id == "dynalite_area_1_preset_1"
func.reset_mock()
await mock_gateway.receive(DynetPacket.set_channel_level_packet(
2, 3, 0, 0))
func.assert_called_once()
devices = func.mock_calls[0][1][0]
assert len(devices) == 1
assert devices[0].unique_id == "dynalite_area_2_channel_3"
async def test_dynalite_devices_auto_discover_off(mock_gateway):
"""Test autodiscover OFF."""
config = {
dyn_const.CONF_ACTIVE: False,
dyn_const.CONF_AUTO_DISCOVER: False,
dyn_const.CONF_AREA: {},
}
mock_gateway.configure_dyn_dev(config, 0)
assert await mock_gateway.async_setup_dyn_dev()
await mock_gateway.check_single_update(None)
func = mock_gateway.new_dev_func
func.reset_mock()
packet_to_send = DynetPacket.report_area_preset_packet(1, 1)
await mock_gateway.receive(packet_to_send)
await mock_gateway.check_notifications([
packet_notification(packet_to_send.raw_msg),
preset_notification(1, 1)
])
func.assert_not_called()
packet_to_send = DynetPacket.set_channel_level_packet(2, 3, 0, 0)
await mock_gateway.receive(packet_to_send)
await mock_gateway.check_notifications(
[packet_notification(packet_to_send.raw_msg)])
func.assert_not_called()
def set_channel_func(area, channel):
"""Create channel set level packet."""
return DynetPacket.set_channel_level_packet(area, channel, 1, 0)
