async def test_handle_panel_event(mocker):
interface = BasicMQTTInterface()
interface.mqtt = mocker.MagicMock()
event = Event()
event.label = "Test"
event.minor = 0
event.major = 0
event.time = datetime.datetime(2019, 10, 18, 17, 15)
interface._handle_panel_event(event)
interface.mqtt.publish.assert_called_once_with(
'paradox/events/raw',
json.dumps(
{
"additional_data": {},
"change": {},
"key": "None,Test,",
"label": "Test",
"level": "NOTSET",
"major": 0,
"message": "",
"minor": 0,
"tags": [],
"time": "2019-10-18T17:15:00",
"timestamp": 0,
"type": None
},
sort_keys=True), 0, True)
def test_mqtt_handle_zone_control_utf8(mocker):
interface = BasicMQTTInterface()
interface.alarm = mocker.MagicMock()
message = MQTTMessage(topic='paradox/control/zones/Előtér'.encode('utf-8'))
message.payload = b'clear_bypass'
interface._mqtt_handle_zone_control(None, None, message)
interface.alarm.control_zone.assert_called_once_with(
"Előtér", "clear_bypass")
def test_mqtt_handle_partition_control(command, expected, mocker):
interface = BasicMQTTInterface()
interface.alarm = mocker.MagicMock()
message = MQTTMessage(topic=b'paradox/control/partition/First_floor')
message.payload = command
interface._mqtt_handle_partition_control(None, None, message)
interface.alarm.control_partition.assert_called_once_with(
"First_floor", expected)
def get_interface(mocker):
mocker.patch("paradox.lib.utils.main_thread_loop", asyncio.get_event_loop())
con = mocker.patch("paradox.interfaces.mqtt.core.MQTTConnection")
con.get_instance.return_value.connected = True
con.get_instance.return_value.availability_topic = "paradox/interface/availability"
con.get_instance.return_value.pai_status_topic = "paradox/interface/pai_status"
interface = BasicMQTTInterface(mocker.MagicMock())
interface.start()
interface.on_connect(None, None, None, None)
return interface
def get_interface(mocker, secret):
mocker.patch.multiple(
cfg,
MQTT_CHALLENGE_SECRET=secret,
MQTT_ENABLE=secret,
MQTT_PUBLISH_COMMAND_STATUS=secret,
)
mocker.MagicMock.__await__ = (
lambda x: async_magic().__await__()
) # Deal with await error
mocker.patch("paradox.lib.utils.main_thread_loop", asyncio.get_event_loop())
con = mocker.patch("paradox.interfaces.mqtt.core.MQTTConnection")
con.get_instance.return_value.connected = True
interface = BasicMQTTInterface(mocker.MagicMock())
interface.start()
interface.on_connect(None, None, None, None)
return interface
def start(self):
if self.conf.GSM_ENABLE:
try:
logger.info("Using GSM Interface")
from paradox.interfaces.text.gsm import GSMTextInterface
self.register(GSMTextInterface())
except Exception:
logger.exception("Unable to start GSM Interface")
# Load Signal service
if self.conf.SIGNAL_ENABLE:
try:
logger.info("Using Signal Interface")
from paradox.interfaces.text.signal import SignalTextInterface
self.register(SignalTextInterface())
except Exception:
logger.exception("Unable to start Signal Interface")
# Load an interface for exposing data and accepting commands
if self.conf.MQTT_ENABLE:
try:
logger.info("Using MQTT Interface")
from paradox.interfaces.mqtt.basic import BasicMQTTInterface
self.register(BasicMQTTInterface())
except Exception:
logger.exception("Unable to start MQTT Interface")
if self.conf.MQTT_HOMEASSISTANT_AUTODISCOVERY_ENABLE:
try:
logger.info("Using HomeAssistant MQTT Interface")
from paradox.interfaces.mqtt.homeassistant import HomeAssistantMQTTInterface
self.register(HomeAssistantMQTTInterface())
except Exception:
logger.exception(
"Unable to start HomeAssistant MQTT Interface")
# Load Pushbullet service
if self.conf.PUSHBULLET_ENABLE:
try:
logger.info("Using Pushbullet Interface")
from paradox.interfaces.text.pushbullet import PushbulletTextInterface
self.register(PushbulletTextInterface())
except Exception:
logger.exception("Unable to start Pushbullet Interface")
# Load Pushover service
if self.conf.PUSHOVER_ENABLE:
try:
logger.info("Using Pushover Interface")
from paradox.interfaces.text.pushover import PushoverTextInterface
self.register(PushoverTextInterface())
except Exception:
logger.exception("Unable to start Pushover Interface")
# Load IP Interface
if self.conf.IP_INTERFACE_ENABLE:
try:
logger.info("Using IP Interface")
from paradox.interfaces.ip_interface import IPInterface
self.register(IPInterface())
except Exception:
logger.exception("Unable to start IP Interface")
# Load Dummy Interface
if self.conf.DUMMY_INTERFACE_ENABLE:
try:
logger.info("Using Dummy Interface")
from paradox.interfaces.text.dummy import DummyInterface
self.register(DummyInterface())
except Exception:
logger.exception("Unable to start Dummy Interface")