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)