def test_partitions_callable_prop(mocker):
alarm = Paradox()
alarm.panel = mocker.MagicMock()
alarm.panel.property_map = {
"arm":
dict(level=EventLevel.INFO,
message={
"True": "{Type} {label} is armed",
"False": "{Type} {label} is disarmed"
}),
}
alarm._on_labels_load(data=dict(
partition={1: dict(id=1, label='Partition 1', key='Partition_1')}))
sendChange = mocker.patch("paradox.data.memory_storage.ps.sendChange")
alarm._on_status_update(status=dict(partition={1: dict(arm=False)}))
sendChange.assert_any_call(
Change('partition', 'Partition_1', 'arm', False, initial=True))
sendChange.reset_mock()
alarm.storage.update_container_object("partition", "Partition_1",
dict(arm=lambda old: not old))
sendChange.assert_any_call(Change('partition', 'Partition_1', 'arm', True))
async def setup_panel(mocker):
mocker.patch.multiple(
cfg, LOGGING_LEVEL_CONSOLE=logging.DEBUG, LOGGING_DUMP_PACKETS=True
)
mocker.patch("paradox.lib.utils.main_thread_loop", asyncio.get_event_loop())
# cfg.LOGGING_LEVEL_CONSOLE = logging.DEBUG
# cfg.LOGGING_DUMP_PACKETS = True
logger.setLevel(logging.DEBUG)
alarm = Paradox()
# alarm.work_loop.set_debug(True)
alarm.run_state = RunState.RUN
start_communication_response = Container(
fields=Container(value=Container(product_id="MAGELLAN_MG5050"))
)
alarm.panel = create_panel(alarm, start_communication_response)
await send_initial_status(alarm)
con = MockConnection(alarm.on_connection_message)
alarm._connection = con
alarm._register_connection_handlers()
return alarm, con
async def test_update_properties(mocker):
alarm = Paradox()
alarm.panel = mocker.MagicMock()
ps = mocker.patch("paradox.lib.ps")
alarm._on_status_update(converted_status)
await asyncio.sleep(0.01)
def test_update_properties(mocker):
alarm = Paradox()
alarm.panel = mocker.MagicMock()
ps = mocker.patch("paradox.lib.ps")
alarm._on_status_update(converted_status)
print(ps)
def alarm(mocker):
mocker.patch('paradox.lib.utils.main_thread_loop', asyncio.get_event_loop())
# conn = mocker.patch("paradox.interfaces.mqtt.core.MQTTConnection")
# conn.connected = True
alarm = Paradox(None)
mocker.spy(alarm.storage, 'update_container_object')
alarm.panel = MagicMock()
return alarm
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
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_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_partitions(mocker):
alarm = Paradox()
alarm.panel = mocker.MagicMock()
alarm.panel.property_map = {
"arm": dict(level=EventLevel.INFO,
message={"True": "{Type} {label} is armed",
"False": "{Type} {label} is disarmed"}),
}
event = mocker.MagicMock()
mocker.patch("paradox.lib.ps.sendChange")
mocker.patch("paradox.lib.ps.sendEvent")
mocker.patch('paradox.event.ChangeEvent', return_value=event)
ps.sendMessage("labels_loaded", data=dict(
partition={
1: dict(
id=1,
label='Partition 1',
key='Partition_1'
)
}
))
assert isinstance(alarm.panel, mocker.MagicMock)
alarm.storage.update_container_object("partition", "Partition_1", dict(arm=True))
ps.sendChange.assert_called_once_with(Change('partition', 'Partition_1', 'arm', True, initial=True))
ps.sendChange.reset_mock()
assert isinstance(alarm.panel, mocker.MagicMock)
ps.sendMessage("status_update", status=dict(
partition={
1: dict(
arm=False
)
}
))
assert isinstance(alarm.panel, mocker.MagicMock)
ps.sendChange.assert_any_call(Change('partition', 'Partition_1', 'current_state', 'disarmed', initial=True))
ps.sendChange.assert_any_call(Change('partition', 'Partition_1', 'target_state', 'disarmed', initial=True))
ps.sendChange.assert_any_call(Change('partition', 'Partition_1', 'arm', False, initial=False))
assert ps.sendChange.call_count == 3
assert ps.sendEvent.call_count == 0
async def test_control_doors(mocker):
alarm = Paradox()
alarm.panel = mocker.Mock(spec=Panel)
alarm.panel.control_doors = CoroutineMock()
alarm.storage.get_container("door").deep_merge(
{1: {
"id": 1,
"key": "Door 1"
}})
assert await alarm.control_door("1", "unlock")
alarm.panel.control_doors.assert_called_once_with([1], "unlock")
alarm.panel.control_doors.reset_mock()
assert await alarm.control_door("Door 1", "unlock")
alarm.panel.control_doors.assert_called_once_with([1], "unlock")
def test_partitions(mocker):
alarm = Paradox()
alarm.panel = mocker.MagicMock()
alarm.panel.property_map = {
"arm":
dict(
level=EventLevel.INFO,
message={
"True": "{Type} {label} is armed",
"False": "{Type} {label} is disarmed",
},
),
}
alarm._on_labels_load(data=dict(
partition={1: dict(id=1, label="Partition 1", key="Partition_1")}))
sendChange = mocker.patch("paradox.data.memory_storage.ps.sendChange")
alarm.storage.update_container_object("partition", "Partition_1",
dict(arm=True))
sendChange.assert_called_once_with(
Change("partition", "Partition_1", "arm", True, initial=True))
sendChange.reset_mock()
assert isinstance(alarm.panel, mocker.MagicMock)
alarm._on_status_update(status=dict(partition={1: dict(arm=False)}))
assert isinstance(alarm.panel, mocker.MagicMock)
sendChange.assert_any_call(
Change("partition",
"Partition_1",
"current_state",
"disarmed",
initial=True))
sendChange.assert_any_call(
Change("partition",
"Partition_1",
"target_state",
"disarmed",
initial=True))
sendChange.assert_any_call(
Change("partition", "Partition_1", "arm", False, initial=False))
def test_current_state_armed_away(mocker):
alarm = Paradox(None)
mocker.spy(alarm.storage, 'update_container_object')
alarm.panel = MagicMock()
send_initial_status(alarm)
sendMessage("status_update", status=dict(
partition={
1: dict(
arm=True
)
}
))
alarm.storage.update_container_object.assert_any_call('partition', 'Partition_1', {
'current_state': 'armed_away',
'target_state': 'armed_away'
})
async def setup_panel(mocker):
mocker.patch.object(cfg, "LOGGING_LEVEL_CONSOLE", logging.DEBUG)
mocker.patch.object(cfg, "LOGGING_DUMP_PACKETS", True)
mocker.patch("paradox.lib.utils.main_thread_loop", asyncio.get_event_loop())
# cfg.LOGGING_LEVEL_CONSOLE = logging.DEBUG
# cfg.LOGGING_DUMP_PACKETS = True
logger.setLevel(logging.DEBUG)
alarm = Paradox()
#alarm.work_loop.set_debug(True)
alarm.run_state = RunState.RUN
alarm.panel = create_panel(alarm, 'MAGELLAN_MG5050')
await send_initial_status(alarm)
con = MockConnection(alarm.on_connection_message)
alarm._connection = con
alarm._register_connection_handlers()
return alarm, con
async def test_send_panic(mocker):
alarm = Paradox()
alarm.panel = mocker.Mock(spec=Panel)
alarm.panel.send_panic = CoroutineMock()
alarm.storage.get_container("partition").deep_merge(
{1: {
"id": 1,
"key": "Partition 1"
}})
alarm.storage.get_container("user").deep_merge(
{3: {
"id": 3,
"key": "User 3"
}})
assert await alarm.send_panic("1", "fire", "3")
alarm.panel.send_panic.assert_called_once_with([1], "fire", 3)
alarm.panel.send_panic.reset_mock()
assert await alarm.send_panic("Partition 1", "fire", "User 3")
alarm.panel.send_panic.assert_called_once_with([1], "fire", 3)
def test_partitions_callable_prop(mocker):
alarm = Paradox()
alarm.panel = mocker.MagicMock()
alarm.panel.property_map = {
"arm": dict(level=EventLevel.INFO,
message={"True": "{Type} {label} is armed",
"False": "{Type} {label} is disarmed"}),
}
event = mocker.MagicMock()
mocker.patch.object(ps, "sendChange")
mocker.patch.object(ps, "sendEvent")
mocker.patch('paradox.event.ChangeEvent', return_value=event)
ps.sendMessage("labels_loaded", data=dict(
partition={
1: dict(
id=1,
label='Partition 1',
key='Partition_1'
)
}
))
ps.sendMessage("status_update", status=dict(
partition={
1: dict(
arm=False
)
}
))
ps.sendChange.assert_any_call(Change('partition', 'Partition_1', 'arm', False, initial=True))
ps.sendChange.reset_mock()
alarm.storage.update_container_object("partition", "Partition_1", dict(arm=lambda old: not old))
ps.sendChange.assert_any_call(Change('partition', 'Partition_1', 'arm', True))
ps.sendEvent.call_count = 0
