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_trigger_switch(mock_gateway):
"""Test a switch that is a single trigger."""
name = "NAME"
[trigger_device] = mock_gateway.configure_dyn_dev(
{
dyn_const.CONF_ACTIVE: False,
dyn_const.CONF_AREA: {
"1": {
dyn_const.CONF_NAME: name,
dyn_const.CONF_TEMPLATE: dyn_const.CONF_TRIGGER,
}
},
},
1,
)
assert await mock_gateway.async_setup_dyn_dev()
await mock_gateway.check_single_update(None)
assert trigger_device.category == "switch"
assert trigger_device.name == name
assert trigger_device.unique_id == "dynalite_area_1_preset_1"
assert trigger_device.available
await trigger_device.async_turn_on()
await mock_gateway.check_single_write(
DynetPacket.select_area_preset_packet(1, 1, 0))
await mock_gateway.check_single_update(trigger_device)
await mock_gateway.check_notifications([preset_notification(1, 1)])
assert trigger_device.is_on
packet_to_send = DynetPacket.report_area_preset_packet(1, 4)
await mock_gateway.receive(packet_to_send)
await mock_gateway.check_single_update(trigger_device)
await mock_gateway.check_notifications([
packet_notification(packet_to_send.raw_msg),
preset_notification(1, 4)
])
assert not trigger_device.is_on
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_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
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_request_area_preset(mock_gateway):
"""Test the command to request and area preset."""
config = {
dyn_const.CONF_ACTIVE: False,
dyn_const.CONF_AREA: {
"1": {},
"2": {
dyn_const.CONF_QUERY_CHANNEL: 6
}
},
dyn_const.CONF_DEFAULT: {
dyn_const.CONF_QUERY_CHANNEL: 3
},
}
mock_gateway.configure_dyn_dev(config, 4)
assert await mock_gateway.async_setup_dyn_dev()
await mock_gateway.check_single_update(None)
mock_gateway.dyn_dev.request_area_preset(1, None)
await mock_gateway.check_single_write(
DynetPacket.request_area_preset_packet(1, 3))
mock_gateway.dyn_dev.request_area_preset(2, None)
await mock_gateway.check_single_write(
DynetPacket.request_area_preset_packet(2, 6))
mock_gateway.dyn_dev.request_area_preset(3, None)
await mock_gateway.check_single_write(
DynetPacket.request_area_preset_packet(3, 3))
mock_gateway.dyn_dev.request_area_preset(4, 9)
await mock_gateway.check_single_write(
DynetPacket.request_area_preset_packet(4, 9))
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_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_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
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
def test_packet_lengths():
"""Test what happens when creating a packet of size not equal to 8."""
packet = DynetPacket(area=3, command=6, data=[1, 2, 3])
with pytest.raises(PacketError):
DynetPacket(packet.msg[0:7])
with pytest.raises(PacketError):
DynetPacket(packet.msg + bytearray([3]))
DynetPacket(packet.msg[0:8])
async def test_light_to_preset(mock_gateway):
"""Test a Dynalite channel that is a light."""
name = "NAME"
channel_name = "CHANNEL"
[device, preset_1, preset_2, preset_3] = mock_gateway.configure_dyn_dev(
{
dyn_const.CONF_ACTIVE: False,
dyn_const.CONF_AREA: {
"1": {
dyn_const.CONF_NAME: name,
dyn_const.CONF_CHANNEL: {
"1": {
dyn_const.CONF_NAME: channel_name,
dyn_const.CONF_FADE: 0.5,
}
},
dyn_const.CONF_PRESET: {
"2": {
dyn_const.CONF_LEVEL: 0.2
}
},
}
},
},
4,
)
assert await mock_gateway.async_setup_dyn_dev()
await mock_gateway.check_single_update(None)
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
# Now send commands
packet_to_send = DynetPacket.fade_area_channel_preset_packet(1, 1, 2, 0.0)
await mock_gateway.receive(packet_to_send)
await mock_gateway.check_single_update(device)
await mock_gateway.check_notifications(
[packet_notification(packet_to_send.raw_msg)])
assert device.brightness == 51
assert device.is_on
# check default preset on
packet_to_send = DynetPacket.fade_area_channel_preset_packet(1, 1, 1, 0.0)
await mock_gateway.receive(packet_to_send)
await mock_gateway.check_single_update(device)
await mock_gateway.check_notifications(
[packet_notification(packet_to_send.raw_msg)])
assert device.brightness == 255
assert device.is_on
# check default preset off
packet_to_send = DynetPacket.fade_area_channel_preset_packet(1, 1, 4, 0.0)
await mock_gateway.receive(packet_to_send)
await mock_gateway.check_single_update(device)
await mock_gateway.check_notifications(
[packet_notification(packet_to_send.raw_msg)])
assert device.brightness == 0
assert not device.is_on
async def test_preset_switch(mock_gateway):
"""Test a Dynalite preset."""
name = "NAME"
preset_name = "PRESET"
[device1, device4] = 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_PRESET: {
"1": {
dyn_const.CONF_NAME: preset_name,
dyn_const.CONF_FADE: 0.5,
},
"4": {
dyn_const.CONF_FADE: 0.7
},
},
}
},
},
2,
)
assert await mock_gateway.async_setup_dyn_dev()
assert device1.category == "switch"
assert device4.category == "switch"
assert device1.name == f"{name} {preset_name}"
assert device4.name == f"{name} Preset 4"
assert device1.unique_id == "dynalite_area_1_preset_1"
await device1.async_turn_on()
await mock_gateway.check_single_write(
DynetPacket.select_area_preset_packet(1, 1, 0.5))
assert device1.is_on
assert not device4.is_on
await device4.async_turn_on()
await asyncio.sleep(0.1)
await mock_gateway.check_single_write(
DynetPacket.select_area_preset_packet(1, 4, 0.7))
assert device4.is_on
assert not device1.is_on
await device4.async_turn_off()
await asyncio.sleep(0.1)
await mock_gateway.check_writes([])
assert not device4.is_on
assert not device1.is_on
await mock_gateway.receive(DynetPacket.select_area_preset_packet(
1, 1, 0.2))
assert not device4.is_on
assert device1.is_on
await mock_gateway.receive(DynetPacket.report_area_preset_packet(1, 4))
assert device4.is_on
assert not device1.is_on
async def test_room_switch(mock_gateway):
"""Test a room switch with two presets."""
name = "NAME"
[on_device, off_device, room_device] = mock_gateway.configure_dyn_dev(
{
dyn_const.CONF_ACTIVE: False,
dyn_const.CONF_AREA: {
"1": {
dyn_const.CONF_NAME: name,
dyn_const.CONF_TEMPLATE: dyn_const.CONF_ROOM,
dyn_const.CONF_PRESET: {
"1": {},
"4": {}
},
}
},
},
3,
)
assert await mock_gateway.async_setup_dyn_dev()
for device in [on_device, off_device, room_device]:
assert device.category == "switch"
assert room_device.name == name
assert device.unique_id == "dynalite_area_1_room_switch"
assert device.available
await room_device.async_turn_on()
await mock_gateway.check_single_write(
DynetPacket.select_area_preset_packet(1, 1, 0))
assert room_device.is_on
assert on_device.is_on
assert not off_device.is_on
await room_device.async_turn_off()
await mock_gateway.check_single_write(
DynetPacket.select_area_preset_packet(1, 4, 0))
assert not room_device.is_on
assert not on_device.is_on
assert off_device.is_on
await on_device.async_turn_on()
await mock_gateway.check_single_write(
DynetPacket.select_area_preset_packet(1, 1, 0))
assert room_device.is_on
assert on_device.is_on
assert not off_device.is_on
await off_device.async_turn_on()
await mock_gateway.check_single_write(
DynetPacket.select_area_preset_packet(1, 4, 0))
assert not room_device.is_on
assert not on_device.is_on
assert off_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()
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_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_cover_no_channel(mock_gateway):
"""Test a cover without an associated channel."""
name = "NAME"
[cover_device] = mock_gateway.configure_dyn_dev({
dyn_const.CONF_ACTIVE: False,
dyn_const.CONF_POLL_TIMER: 0.05,
dyn_const.CONF_AREA: {
"1": {
dyn_const.CONF_NAME: name,
dyn_const.CONF_TEMPLATE: dyn_const.CONF_TIME_COVER,
dyn_const.CONF_DURATION: 0.5,
dyn_const.CONF_OPEN_PRESET: 1,
dyn_const.CONF_CLOSE_PRESET: 2,
dyn_const.CONF_STOP_PRESET: 3,
}
},
})
assert await mock_gateway.async_setup_dyn_dev()
assert cover_device.category == "cover"
# It is closed. Let's open
assert cover_device.is_closed
await cover_device.async_open_cover()
await mock_gateway.check_single_write(
DynetPacket.select_area_preset_packet(1, 1, 0))
await asyncio.sleep(0.25)
assert cover_device.is_opening
assert 40 < cover_device.current_cover_position < 60
await asyncio.sleep(0.4)
assert (not cover_device.is_closed and not cover_device.is_opening
and not cover_device.is_closing)
assert cover_device.current_cover_position == 100
async def test_cover_no_channel(mock_gateway):
"""Test a cover without an associated channel."""
name = "NAME"
[cover_device] = mock_gateway.configure_dyn_dev({
dyn_const.CONF_ACTIVE: False,
dyn_const.CONF_POLL_TIMER: 0.05,
dyn_const.CONF_AREA: {
"1": {
dyn_const.CONF_NAME: name,
dyn_const.CONF_TEMPLATE: dyn_const.CONF_TIME_COVER,
dyn_const.CONF_DURATION: 0.5,
dyn_const.CONF_OPEN_PRESET: 1,
dyn_const.CONF_CLOSE_PRESET: 2,
dyn_const.CONF_STOP_PRESET: 3,
}
},
})
assert await mock_gateway.async_setup_dyn_dev()
await mock_gateway.check_single_update(None)
assert cover_device.category == "cover"
# Initialize to closed - otherwise it takes the first one as the init status
packet_to_send = DynetPacket.report_area_preset_packet(1, 2)
await mock_gateway.receive(packet_to_send)
await mock_gateway.check_updates([cover_device], True)
await mock_gateway.check_notifications([
packet_notification(packet_to_send.raw_msg),
preset_notification(1, 2)
])
# It is closed. Let's open
assert cover_device.is_closed
await cover_device.async_open_cover()
await mock_gateway.check_single_write(
DynetPacket.select_area_preset_packet(1, 1, 0))
await mock_gateway.check_updates([cover_device], True)
await mock_gateway.check_notifications([preset_notification(1, 1)])
await asyncio.sleep(0.25)
await mock_gateway.check_updates([cover_device], True)
assert cover_device.is_opening
assert 40 < cover_device.current_cover_position < 60
await asyncio.sleep(0.4)
await mock_gateway.check_updates([cover_device], True)
assert (not cover_device.is_closed and not cover_device.is_opening
and not cover_device.is_closing)
assert cover_device.current_cover_position == 100
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_inbound_request_channel_level(mock_gateway):
"""Test when the network requests a channel level. Nothing to do, just be sure nothing bad happens..."""
[device] = mock_gateway.configure_dyn_dev(
{
dyn_const.CONF_ACTIVE: False,
dyn_const.CONF_AREA: {"3": {dyn_const.CONF_CHANNEL: {"5": {}}}},
dyn_const.CONF_PRESET: {},
},
1,
)
assert not device.is_on
assert await mock_gateway.async_setup_dyn_dev()
await mock_gateway.receive(DynetPacket.request_channel_level_packet(3, 5))
assert not 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()
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()
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_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_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_active(mock_gateway, active):
"""Test with active set to ON."""
[_, _, device_pres] = mock_gateway.configure_dyn_dev(
{
dyn_const.CONF_ACTIVE: active,
dyn_const.CONF_AREA: {
"1": {
dyn_const.CONF_CHANNEL: {
"1": {},
"2": {}
}
}
},
dyn_const.CONF_PRESET: {
"1": {}
},
},
3,
)
assert await mock_gateway.async_setup_dyn_dev()
await mock_gateway.check_single_update(None)
if active is not False:
await mock_gateway.check_writes([
DynetPacket.request_channel_level_packet(1, 1),
DynetPacket.request_channel_level_packet(1, 2),
DynetPacket.request_area_preset_packet(1, 1),
])
else:
await mock_gateway.check_writes([])
packet_to_send = DynetPacket.report_area_preset_packet(1, 1)
await mock_gateway.receive(packet_to_send)
await mock_gateway.check_single_update(device_pres)
await mock_gateway.check_notifications([
packet_notification(packet_to_send.raw_msg),
preset_notification(1, 1)
])
if active is True:
await mock_gateway.check_writes([
DynetPacket.request_channel_level_packet(1, 1),
DynetPacket.request_channel_level_packet(1, 2),
])
else:
await mock_gateway.check_writes([])
async def test_dynalite_devices_active(mock_gateway, active):
"""Test with active set to ON."""
mock_gateway.configure_dyn_dev(
{
dyn_const.CONF_ACTIVE: active,
dyn_const.CONF_AREA: {
"1": {
dyn_const.CONF_CHANNEL: {
"1": {},
"2": {}
}
}
},
dyn_const.CONF_PRESET: {
"1": {}
},
},
3,
)
assert await mock_gateway.async_setup_dyn_dev()
if active is not False:
await mock_gateway.check_writes([
DynetPacket.request_channel_level_packet(1, 1),
DynetPacket.request_channel_level_packet(1, 2),
DynetPacket.request_area_preset_packet(1),
])
else:
await mock_gateway.check_writes([])
await mock_gateway.receive(DynetPacket.report_area_preset_packet(1, 1))
if active is True:
await mock_gateway.check_writes([
DynetPacket.request_channel_level_packet(1, 1),
DynetPacket.request_channel_level_packet(1, 2),
])
else:
await mock_gateway.check_writes([])
def preset_select_func(area, preset):
"""Create preset selection packet."""
return DynetPacket.select_area_preset_packet(area, preset, 0)
def report_channel_func(area, channel):
"""Create channel report level packet."""
return DynetPacket.report_channel_level_packet(area, channel, 1, 1)
