def test_zone_generated_alarm_changes_match(mocker):
label_provider = mocker.MagicMock(return_value="Beer")
payload = binascii.unhexlify(
'e2ff1cc414130b010f2c1801030000000000024f66666963652020202020202020202000d9'
)
raw = LiveEventMessage.parse(payload)
event_ = LiveEvent(raw, event_map, label_provider=label_provider)
assert EventTagFilter(['generated_alarm=True']).match(event_) is True
assert EventTagFilter(['generated_alarm=False']).match(event_) is False
assert EventTagFilter(['generated_alarm=']).match(event_) is True
assert EventTagFilter(['-generated_alarm=']).match(event_) is False
assert EventTagFilter(['-generated_alarm=True']).match(event_) is False
assert EventTagFilter(['-generated_alarm=False']).match(event_) is True
assert EventTagFilter(['zone-generated_alarm=beer']).match(event_) is True
assert EventTagFilter(['zone+generated_alarm=beer']).match(event_) is False
assert EventTagFilter(['generated_alarm=True+presently_in_alarm=True'
]).match(event_) is True
assert EventTagFilter(['generated_alarm=True-presently_in_alarm=True'
]).match(event_) is False
assert EventTagFilter(['-generated_alarm=False']).match(event_) is True
with pytest.raises(AssertionError):
EventTagFilter(['-=False'])
with pytest.raises(AssertionError):
EventTagFilter(['-""=False'])
def test_event_winload_connected():
payload = b'\xe2\xff\xaa\xb0\x14\x13\x01\x04\x0b$-\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc7'
raw = LiveEvent.parse(payload)
event = Event(event_map, raw)
assert "Special events: WinLoad in (connected)" == event.message
print(event)
def test_event_clock_restore():
payload = b'\xe2\xff\xaa\xb1\x14\x13\x01\x04\x0b$%\x00\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc2'
raw = LiveEvent.parse(payload)
event = Event(event_map, raw)
assert "Trouble restore: Clock loss restore" == event.message
print(event)
def test_disconnect_event():
payload = b'\xe0\xff\xe1\xe8\x14\x13\x02\x11\x0f%-\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00H'
raw = LiveEvent.parse(payload)
event = Event(event_map, raw)
assert "Special events: WinLoad out (disconnected)" == event.message
print(event)
def test_door_user2(mocker):
payload = b"\xe2\xff\xad\x06\x14\x13\x01\x04\x0e\x10\x06\x01\x05\x01\x00\x00\x00\x00\x02Living room \x00\xd3"
raw = LiveEvent.parse(payload)
def label_provider(type, id):
if type == "user":
assert id == 5
return "Test"
elif type == "partition":
assert id == 5
return "First floor"
elif type == "door":
assert id == 5
return "Door 1"
else:
assert False
mocker.patch.dict(
event_map[6], {"message": "User {@user#minor} access on door {@door}"}
)
event_ = event.LiveEvent(raw, event_map, label_provider=label_provider)
assert "User Test access on door Door 1" == event_.message
print(event_)
def test_door_user2():
payload = b'\xe2\xff\xad\x06\x14\x13\x01\x04\x0e\x10\x06\x01\x05\x01\x00\x00\x00\x00\x02Living room \x00\xd3'
raw = LiveEvent.parse(payload)
def label_provider(type, id):
if type == 'user':
assert id == 5
return 'Test'
elif type == 'partition':
assert id == 5
return 'First floor'
elif type == 'door':
assert id == 5
return 'Door 1'
else:
assert False
# monkey patch
event_map[6]['message'] = 'User {@user#minor} access on door {@door}'
event = Event(event_map, raw, label_provider=label_provider)
assert "User Test access on door Door 1" == event.message
print(event)
def test_zone_generated_alarm_match(mocker):
label_provider = mocker.MagicMock(return_value="Beer")
payload = binascii.unhexlify(
'e2ff1cc414130b010f2c1801030000000000024f66666963652020202020202020202000d9'
)
raw = LiveEventMessage.parse(payload)
event_ = LiveEvent(raw, event_map, label_provider=label_provider)
assert "Zone Office in alarm" == event_.message
assert EventTagFilter(['zone+alarm']).match(event_) is True
label_provider.assert_called_once_with("zone", 3)
assert EventTagFilter(['zone-alarm']).match(event_) is False
# Live event label
assert EventTagFilter(['zone,alarm,"Office"']).match(event_) is True
assert EventTagFilter(['zone,alarm,-"Office"']).match(event_) is False
assert EventTagFilter(['zone,alarm,Office']).match(event_) is True
assert EventTagFilter(['zone,alarm,-Office']).match(event_) is False
assert EventTagFilter(['zone,alarm,Offic']).match(event_) is False
# returned from label_provider
assert EventTagFilter(['zone,alarm,Beer']).match(event_) is True
assert EventTagFilter(['zone,alarm,-Beer']).match(event_) is False
def test_partition_armed_by_pai():
payload = binascii.unhexlify(
'e2ff187914130b0e0e3b0c0101000000000000000000000000000000000000000000000009'
)
raw = LiveEvent.parse(payload)
event_ = event.LiveEvent(raw, event_map)
assert "Special arming [partition:1]: arming with Winload by [user:0]" == event_.message
print(event_)
def test_partition_disarmed_by_user_master():
payload = binascii.unhexlify(
"e2ffe86e1414030d15390d0801000000000001546573740000000000000000000000000074"
)
raw = LiveEvent.parse(payload)
event_ = event.LiveEvent(raw, event_map)
assert "[partition:8] disarmed with [user:1] master code" == event_.message
print(event_)
def test_partition_disarmed_by_user():
payload = binascii.unhexlify(
"e2ffe85e1414030d152c0e0802000000000001546573740000000000000000000000000059"
)
raw = LiveEvent.parse(payload)
event_ = event.LiveEvent(raw, event_map)
assert "[partition:8] disarmed with [user:2] code" == event_.message
print(event_)
def test_partition_armed_by_user():
payload = binascii.unhexlify(
"e2ffe8601414030d152d0a0802000000000001546573740000000000000000000000000058"
)
raw = LiveEvent.parse(payload)
event_ = event.LiveEvent(raw, event_map)
assert "Arming [partition:8] with [user:2] code" == event_.message
print(event_)
def test_zone_alarm_restored():
payload = binascii.unhexlify(
"e2ff1cd914130b010f2f1a0102000000000002456e7472616e636520202020202020200096"
)
raw = LiveEvent.parse(payload)
event_ = event.LiveEvent(raw, event_map)
assert "Zone Entrance alarm restore" == event_.message
print(event_)
def test_zone_generated_alarm():
payload = binascii.unhexlify(
"e2ff1cc414130b010f2c1801030000000000024f66666963652020202020202020202000d9"
)
raw = LiveEvent.parse(payload)
event_ = event.LiveEvent(raw, event_map)
assert "Zone Office in alarm" == event_.message
print(event_)
def test_zone_open():
payload = b'\xe2\xff\xad\x06\x14\x13\x01\x04\x0e\x10\x01\x01\x05\x00\x00\x00\x00\x00\x02Living room \x00\xcd'
raw = LiveEvent.parse(payload)
event = Event(event_map, raw, label_provider=label_provider)
assert event.change == {'open': True}
assert "Zone Living room open" == event.message
print(event)
def test_zone_open():
payload = b"\xe2\xff\xad\x06\x14\x13\x01\x04\x0e\x10\x01\x01\x05\x00\x00\x00\x00\x00\x02Living room \x00\xcd"
raw = LiveEvent.parse(payload)
event_ = event.LiveEvent(raw, event_map, label_provider=label_provider)
assert event_.change == {"open": True}
assert "Zone Living room open" == event_.message
print(event_)
def test_event_clock_restore():
payload = b"\xe2\xff\xaa\xb1\x14\x13\x01\x04\x0b$%\x00\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc2"
raw = LiveEvent.parse(payload)
event_ = event.LiveEvent(raw, event_map)
print(event_)
assert "Trouble restore: Clock loss restore" == event_.message
assert all(t in event_.tags for t in ["trouble", "clock"])
def test_handler_two_messages():
def event_handler(message):
print("event")
return "event"
async def get_eeprom_result(mhm):
return await mhm.wait_for_message(
lambda m: m.fields.value.po.command == 0x5)
event_response_bin = b'\xe2\xff\xad\x06\x14\x13\x01\x04\x0e\x10\x00\x01\x05\x00\x00\x00\x00\x00\x02Living room \x00\xcc'
eeprom_response_bin = binascii.unhexlify(
'524700009f0041133e001e0e0400000000060a0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000121510010705004e85'
)
loop = asyncio.get_event_loop()
mh = AsyncMessageManager(loop)
event_handler = EventMessageHandler(event_handler)
mh.register_handler(event_handler)
# running
task_handle_wait = loop.create_task(asyncio.sleep(0.1))
task_get_eeprom = loop.create_task(get_eeprom_result(mh))
task_handle_event1 = loop.create_task(
mh._handle_message(LiveEvent.parse(event_response_bin)))
loop.create_task(
mh._handle_message(ReadEEPROMResponse.parse(eeprom_response_bin)))
task_handle_event2 = loop.create_task(
mh._handle_message(LiveEvent.parse(event_response_bin)))
# assert 2 == len(mh.handlers)
loop.run_until_complete(
asyncio.gather(task_handle_wait, task_get_eeprom, loop=loop))
assert 1 == len(mh.handlers)
assert task_handle_event1.result(
) == "event" # failed to parse response message return None. Maybe needs to throw something.
assert isinstance(task_get_eeprom.result(), Container)
assert task_handle_event2.result() == "event"
assert 1 == len(mh.handlers)
def test_door_user(mocker):
payload = b"\xe2\xff\xad\x06\x14\x13\x01\x04\x0e\x10\x06\x01\x05\x01\x00\x00\x00\x00\x02Living room \x00\xd3"
raw = LiveEvent.parse(payload)
mocker.patch.dict(event_map[6], {"message": "User {@user} access on door {@door}"})
event_ = event.LiveEvent(raw, event_map, label_provider=label_provider)
assert "User Test access on door Door 1" == event_.message
print(event_)
def test_door_user():
payload = b'\xe2\xff\xad\x06\x14\x13\x01\x04\x0e\x10\x06\x01\x05\x01\x00\x00\x00\x00\x02Living room \x00\xd3'
raw = LiveEvent.parse(payload)
# monkey patch
event_map[6]['message'] = 'User {@user} access on door {@door}'
event = Event(event_map, raw, label_provider=label_provider)
assert "User Test access on door Door 1" == event.message
print(event)
def test_handler_timeout():
def event_handler(message):
print("event")
return "event"
async def get_eeprom_result(mhm):
try:
return await mhm.wait_for_message(
lambda m: m.fields.value.po.command == 0x5, timeout=0.1)
except asyncio.TimeoutError:
return None
async def post_eeprom_message(mhm):
await asyncio.sleep(0.2)
eeprom_response_bin = binascii.unhexlify(
'524700009f0041133e001e0e0400000000060a0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000121510010705004e85'
)
return await mhm._handle_message(
ReadEEPROMResponse.parse(eeprom_response_bin))
loop = asyncio.get_event_loop()
mh = AsyncMessageManager(loop)
# running
task_handle_wait = loop.create_task(asyncio.sleep(0.1))
task_get_eeprom = loop.create_task(get_eeprom_result(mh))
loop.create_task(post_eeprom_message(mh))
assert 0 == len(mh.handlers)
loop.run_until_complete(
asyncio.gather(task_handle_wait, task_get_eeprom, loop=loop))
assert 1 == len(mh.handlers)
event_handler = EventMessageHandler(event_handler)
mh.register_handler(event_handler)
event_response_bin = b'\xe2\xff\xad\x06\x14\x13\x01\x04\x0e\x10\x00\x01\x05\x00\x00\x00\x00\x00\x02Living room \x00\xcc'
task_handle_event1 = mh.schedule_message_handling(
LiveEvent.parse(event_response_bin))
loop.run_until_complete(task_handle_event1)
assert 1 == len(mh.handlers)
result = task_get_eeprom.result()
assert result is None
def test_current_alarm(mocker):
alarm = Paradox(None)
mocker.spy(alarm.storage, 'update_container_object')
alarm.panel = Panel_EVO192(alarm, 5)
send_initial_status(alarm)
payload = binascii.unhexlify('e2ff1cc414130b010f2c1801030000000000024f66666963652020202020202020202000d9')
raw = LiveEvent.parse(payload)
alarm.handle_event_message(raw)
alarm.storage.update_container_object.assert_any_call('partition', 'Partition_1', {
'current_state': 'triggered'
})
def test_handler_timeout():
def event_handler(message):
print("event received")
async def get_eeprom_result(mhm):
return await mhm.wait_for_message(
lambda m: m.fields.value.po.command == 0x5, timeout=0.1)
async def post_eeprom_message(mhm):
await asyncio.sleep(0.2)
eeprom_response_bin = binascii.unhexlify(
"524700009f0041133e001e0e0400000000060a0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000121510010705004e85"
)
return await mhm.schedule_message_handling(
ReadEEPROMResponse.parse(eeprom_response_bin))
loop = asyncio.get_event_loop()
mh = AsyncMessageManager(loop)
# running
task_get_eeprom = loop.create_task(get_eeprom_result(mh))
loop.create_task(post_eeprom_message(mh))
assert 0 == len(mh.handler_registry)
with pytest.raises(asyncio.TimeoutError):
loop.run_until_complete(task_get_eeprom)
assert 0 == len(mh.handler_registry)
# Also test EventMessageHandler
event_handler = EventMessageHandler(event_handler)
mh.register_handler(event_handler)
event_response_bin = b"\xe2\xff\xad\x06\x14\x13\x01\x04\x0e\x10\x00\x01\x05\x00\x00\x00\x00\x00\x02Living room \x00\xcc"
task_handle_event1 = mh.schedule_message_handling(
LiveEvent.parse(event_response_bin))
assert 1 == len(mh.handler_registry)
loop.run_until_complete(task_handle_event1)
assert 1 == len(mh.handler_registry)
async def test_current_alarm(mocker):
mocker.patch('paradox.lib.utils.main_thread_loop', asyncio.get_event_loop())
alarm = Paradox(None)
alarm.panel = Panel_EVO192(alarm, 5)
mocker.spy(alarm.storage, 'update_container_object')
send_initial_status(alarm)
payload = binascii.unhexlify('e2ff1cc414130b010f2c1801030000000000024f66666963652020202020202020202000d9')
raw = LiveEvent.parse(payload)
alarm.handle_event_message(raw)
await asyncio.sleep(0.01)
alarm.storage.update_container_object.assert_any_call('partition', 'Partition_1', {
'current_state': 'triggered'
})
alarm.panel = None
def test_event_handler():
eh = EventMessageHandler(print_beer)
loop = asyncio.get_event_loop()
mh = AsyncMessageManager(loop)
mh.register_handler(eh)
assert 1 == len(mh.handler_registry)
payload = b"\xe2\xff\xad\x06\x14\x13\x01\x04\x0e\x10\x00\x01\x05\x00\x00\x00\x00\x00\x02Living room \x00\xcc"
message = LiveEvent.parse(payload)
coro = asyncio.ensure_future(mh.schedule_message_handling(message))
loop.run_until_complete(coro)
assert 1 == len(mh.handler_registry)
def test_zone_ok():
payload = b'\xe2\xff\xad\x06\x14\x13\x01\x04\x0e\x10\x00\x01\x05\x00\x00\x00\x00\x00\x02Living room \x00\xcc'
raw = LiveEvent.parse(payload)
def label_provider(type, id):
assert type == 'partition'
assert id == 1
return 'First floor'
# monkey patch
event_map[0]['message'] = 'Zone {label} OK in partition {@partition}'
event = Event(event_map, raw, label_provider=label_provider)
assert event.change == {'open': False}
assert "Zone Living room OK in partition First floor" == event.message
print(event)
def test_event_handler():
eh = EventMessageHandler(lambda m: "beer")
loop = asyncio.get_event_loop()
mh = AsyncMessageManager(loop)
mh.register_handler(eh)
assert 1 == len(mh.handlers)
payload = b'\xe2\xff\xad\x06\x14\x13\x01\x04\x0e\x10\x00\x01\x05\x00\x00\x00\x00\x00\x02Living room \x00\xcc'
message = LiveEvent.parse(payload)
coro = asyncio.ensure_future(mh._handle_message(message))
loop.run_until_complete(coro)
assert "beer" == coro.result()
assert 1 == len(mh.handlers)
def test_zone_ok(mocker):
payload = b"\xe2\xff\xad\x06\x14\x13\x01\x04\x0e\x10\x00\x01\x05\x00\x00\x00\x00\x00\x02Living room \x00\xcc"
raw = LiveEvent.parse(payload)
def my_label_provider(type, id):
assert type == "partition"
assert id == 1
return "First floor"
mocker.patch.dict(
event_map[0], {"message": "Zone {label} OK in partition {@partition}"}
)
event_ = event.LiveEvent(raw, event_map, label_provider=my_label_provider)
assert event_.change == {"open": False}
assert "Zone Living room OK in partition First floor" == event_.message
print(event_)
async def test_current_alarm(mocker):
mocker.patch("paradox.lib.utils.main_thread_loop",
asyncio.get_event_loop())
alarm = Paradox(None)
alarm.panel = create_evo192_panel(alarm)
mocker.spy(alarm.storage, "update_container_object")
send_initial_status(alarm)
payload = binascii.unhexlify(
"e2ff1cc414130b010f2c1801030000000000024f66666963652020202020202020202000d9"
)
raw = LiveEvent.parse(payload)
alarm.handle_event_message(raw)
await asyncio.sleep(0.01)
alarm.storage.update_container_object.assert_any_call(
"partition", "Partition_1", {"current_state": "triggered"})
alarm.panel = None
def test_door_access():
payload = b"\xe0\xff\xc1d\x14\x13\x0c\x05\x11\x19\x06\x00\x01\n\x00\x00\x00\x00\x03V\x99LIKS DOOR\x00\x00\x00\x00\x00+\x1b"
raw = LiveEvent.parse(payload)
event_ = event.LiveEvent(raw, event_map)
assert "[user:10] access on door VLIKS DOOR" == event_.message
print(event_)
def test_door_access_granted():
payload = b"\xe0\xff\xc1c\x14\x13\x0c\x05\x11\x19>\x00\n\x01\x00\x00\x00\x00\x01First Lastname \x001\x5d"
raw = LiveEvent.parse(payload)
event_ = event.LiveEvent(raw, event_map)
assert "[door:1] access granted to user First Lastname" == event_.message
print(event_)
