def onIntentParsed(self, session: DialogSession):
if not self._getJidBySessionId(session.sessionId):
return
intent = Intent(session.payload['intent']['intentName'].split(':')[1])
message = MQTTMessage(topic=str.encode(str(intent)))
message.payload = json.dumps(session.payload)
self.MqttManager.onMessage(client=None, userdata=None, message=message)
def test__mqtt_command_callback_ignore_retained(caplog, topic: bytes,
payload: bytes):
ActorMock = _mock_actor_class(
switchbot_mqtt._ButtonAutomator.MQTT_COMMAND_TOPIC_LEVELS)
message = MQTTMessage(topic=topic)
message.payload = payload
message.retain = True
with unittest.mock.patch.object(
ActorMock, "__init__",
return_value=None) as init_mock, unittest.mock.patch.object(
ActorMock,
"execute_command") as execute_command_mock, caplog.at_level(
logging.DEBUG):
ActorMock._mqtt_command_callback(
"client_dummy",
switchbot_mqtt._MQTTCallbackUserdata(retry_count=4,
device_passwords={}),
message,
)
init_mock.assert_not_called()
execute_command_mock.assert_not_called()
assert caplog.record_tuples == [
(
"switchbot_mqtt",
logging.DEBUG,
"received topic={} payload={!r}".format(topic.decode(), payload),
),
("switchbot_mqtt", logging.INFO, "ignoring retained message"),
]
def test__mqtt_command_callback_invalid_mac_address(caplog, mac_address: str,
payload: bytes):
ActorMock = _mock_actor_class(
switchbot_mqtt._ButtonAutomator.MQTT_COMMAND_TOPIC_LEVELS)
topic = "homeassistant/switch/switchbot/{}/set".format(
mac_address).encode()
message = MQTTMessage(topic=topic)
message.payload = payload
with unittest.mock.patch.object(
ActorMock, "__init__",
return_value=None) as init_mock, unittest.mock.patch.object(
ActorMock,
"execute_command") as execute_command_mock, caplog.at_level(
logging.DEBUG):
ActorMock._mqtt_command_callback(
"client_dummy",
switchbot_mqtt._MQTTCallbackUserdata(retry_count=3,
device_passwords={}),
message,
)
init_mock.assert_not_called()
execute_command_mock.assert_not_called()
assert caplog.record_tuples == [
(
"switchbot_mqtt",
logging.DEBUG,
"received topic={} payload={!r}".format(topic.decode(), payload),
),
(
"switchbot_mqtt",
logging.WARNING,
"invalid mac address {}".format(mac_address),
),
]
def test__mqtt_command_callback_password(mac_address, expected_password):
ActorMock = _mock_actor_class([
"switchbot",
switchbot_mqtt._MQTTTopicPlaceholder.MAC_ADDRESS,
])
message = MQTTMessage(topic=b"switchbot/" + mac_address.encode())
message.payload = b"whatever"
callback_userdata = switchbot_mqtt._MQTTCallbackUserdata(
retry_count=3,
device_passwords={
"11:22:33:44:55:77": "test",
"aa:bb:cc:dd:ee:ff": "secret",
"11:22:33:dd:ee:ff": "äöü",
},
)
with unittest.mock.patch.object(
ActorMock, "__init__",
return_value=None) as init_mock, unittest.mock.patch.object(
ActorMock, "execute_command") as execute_command_mock:
ActorMock._mqtt_command_callback("client_dummy", callback_userdata,
message)
init_mock.assert_called_once_with(mac_address=mac_address,
retry_count=3,
password=expected_password)
execute_command_mock.assert_called_once_with(
mqtt_client="client_dummy", mqtt_message_payload=b"whatever")
def doDialog(self, jid: str, text: str):
session = None
if jid not in self._sessions:
mesg = MQTTMessage()
mesg.payload = f'{{"siteId": "{jid}"}}'
session = self.DialogSessionManager.preSession(jid, 'sergio')
session = self.DialogSessionManager.addSession(
str(uuid.uuid4()), mesg)
self._sessions[jid] = session.sessionId
else:
sessionId = self._sessions[jid]
session = self.DialogSessionManager.getSession(sessionId)
self._refreshSession(session)
result = self.LanguageManager.sanitizeNluQuery(text)
supportedIntents = session.intentFilter or self.ModuleManager.supportedIntents
intentFilter = [
intent.justTopic for intent in supportedIntents
if isinstance(intent, Intent) and not intent.protected
]
# Add Global Intents
intentFilter.append(Intent('GlobalStop').justTopic)
self.MqttManager.publish(topic=constants.TOPIC_NLU_QUERY,
payload={
'siteId': jid,
'input': result,
'intentFilter': intentFilter,
'id': session.sessionId,
'sessionId': session.sessionId
})
def test__mqtt_update_device_info_callback_ignore_retained(
caplog: _pytest.logging.LogCaptureFixture, ) -> None:
ActorMock = _mock_actor_class(
request_info_levels=(_MQTTTopicPlaceholder.MAC_ADDRESS, "request"))
message = MQTTMessage(topic=b"aa:bb:cc:dd:ee:ff/request")
message.payload = b""
message.retain = True
with unittest.mock.patch.object(
ActorMock, "__init__",
return_value=None) as init_mock, unittest.mock.patch.object(
ActorMock,
"execute_command") as execute_command_mock, caplog.at_level(
logging.DEBUG):
ActorMock._mqtt_update_device_info_callback(
"client_dummy",
_MQTTCallbackUserdata(
retry_count=21,
device_passwords={},
fetch_device_info=True,
mqtt_topic_prefix="ignored",
),
message,
)
init_mock.assert_not_called()
execute_command_mock.assert_not_called()
assert caplog.record_tuples == [
(
"switchbot_mqtt._actors.base",
logging.DEBUG,
"received topic=aa:bb:cc:dd:ee:ff/request payload=b''",
),
("switchbot_mqtt._actors.base", logging.INFO,
"ignoring retained message"),
]
def test__mqtt_on_message_ignored_retained(topic: bytes, payload: bytes):
message = MQTTMessage(topic=topic)
message.payload = payload
message.retain = True
with unittest.mock.patch("switchbot_mqtt._send_command") as send_command_mock:
switchbot_mqtt._mqtt_on_message(None, None, message)
assert not send_command_mock.called
def process(self):
try:
siteId = request.form.get('siteId') if request.form.get(
'siteId', None
) is not None else self.ConfigManager.getAliceConfigByName('uuid')
user = self.UserManager.getUserByAPIToken(
request.headers.get('auth', ''))
session = self.DialogManager.newSession(siteId=siteId,
user=user.name)
# Turn off the wakeword component
self.MqttManager.publish(topic=constants.TOPIC_HOTWORD_TOGGLE_OFF,
payload={
'siteId': siteId,
'sessionId': session.sessionId
})
message = MQTTMessage()
message.payload = json.dumps({
'sessionId': session.sessionId,
'siteId': siteId,
'text': request.form.get('query')
})
session.extend(message=message)
self.MqttManager.publish(topic=constants.TOPIC_NLU_QUERY,
payload={
'input': request.form.get('query'),
'sessionId': session.sessionId
})
return jsonify(success=True, sessionId=session.sessionId)
except Exception as e:
self.logError(f'Failed processing: {e}')
return jsonify(success=False)
def test_status_handler(self, fakedevice):
EventDefinitionFactory(device=fakedevice, product=None)
with mock.patch(IBM + ".connect") as connect, \
mock.patch(IBM + ".subscribeToDeviceEvents") as subscribe, \
mock.patch(IBM + ".subscribeToDeviceStatus"), \
mock.patch("zconnect.handlers.logger.info") as info_log:
topic = "iot-2/type/testproduct123/id/{}/mon"
topic = topic.format(fakedevice.id).encode("utf8")
paho_message = MQTTMessage(topic=topic)
paho_message.payload = b'{"Action": "Connect"}'
event = Status(paho_message)
greenlet = get_listener()
greenlet.client.subscribe_to_events()
greenlet.client.broker_interface.deviceStatusCallback(event)
assert connect.called
assert subscribe.called
assert info_log.called
msg = "Connection message success (device: %s) (action: %s)"
assert info_log.call_args_list == [
mock.call(msg, fakedevice.id, "Connect"),
]
def test__mqtt_command_callback_password(
mac_address: str, expected_password: typing.Optional[str]) -> None:
ActorMock = _mock_actor_class(
command_topic_levels=("switchbot", _MQTTTopicPlaceholder.MAC_ADDRESS))
message = MQTTMessage(topic=b"prefix-switchbot/" + mac_address.encode())
message.payload = b"whatever"
callback_userdata = _MQTTCallbackUserdata(
retry_count=3,
device_passwords={
"11:22:33:44:55:77": "test",
"aa:bb:cc:dd:ee:ff": "secret",
"11:22:33:dd:ee:ff": "äöü",
},
fetch_device_info=True,
mqtt_topic_prefix="prefix-",
)
with unittest.mock.patch.object(
ActorMock, "__init__",
return_value=None) as init_mock, unittest.mock.patch.object(
ActorMock, "execute_command") as execute_command_mock:
ActorMock._mqtt_command_callback("client_dummy", callback_userdata,
message)
init_mock.assert_called_once_with(mac_address=mac_address,
retry_count=3,
password=expected_password)
execute_command_mock.assert_called_once_with(
mqtt_client="client_dummy",
mqtt_message_payload=b"whatever",
update_device_info=True,
mqtt_topic_prefix="prefix-",
)
def test__mqtt_command_callback(
caplog,
command_topic_levels: typing.List[switchbot_mqtt._MQTTTopicLevel],
topic: bytes,
payload: bytes,
expected_mac_address: str,
retry_count: int,
):
ActorMock = _mock_actor_class(command_topic_levels)
message = MQTTMessage(topic=topic)
message.payload = payload
callback_userdata = switchbot_mqtt._MQTTCallbackUserdata(
retry_count=retry_count, device_passwords={})
with unittest.mock.patch.object(
ActorMock, "__init__",
return_value=None) as init_mock, unittest.mock.patch.object(
ActorMock,
"execute_command") as execute_command_mock, caplog.at_level(
logging.DEBUG):
ActorMock._mqtt_command_callback("client_dummy", callback_userdata,
message)
init_mock.assert_called_once_with(mac_address=expected_mac_address,
retry_count=retry_count,
password=None)
execute_command_mock.assert_called_once_with(mqtt_client="client_dummy",
mqtt_message_payload=payload)
assert caplog.record_tuples == [(
"switchbot_mqtt",
logging.DEBUG,
"received topic={} payload={!r}".format(topic.decode(), payload),
)]
def test__mqtt_set_position_callback_invalid_position(
caplog: _pytest.logging.LogCaptureFixture,
payload: bytes,
) -> None:
callback_userdata = _MQTTCallbackUserdata(
retry_count=3,
device_passwords={},
fetch_device_info=False,
mqtt_topic_prefix="homeassistant/",
)
message = MQTTMessage(
topic=
b"homeassistant/cover/switchbot-curtain/aa:bb:cc:dd:ee:ff/position/set-percent"
)
message.payload = payload
with unittest.mock.patch(
"switchbot.SwitchbotCurtain") as device_init_mock, caplog.at_level(
logging.INFO):
_CurtainMotor._mqtt_set_position_callback(mqtt_client="client dummy",
userdata=callback_userdata,
message=message)
device_init_mock.assert_called_once()
device_init_mock().set_position.assert_not_called()
assert caplog.record_tuples == [
(
"switchbot_mqtt._actors",
logging.WARN,
f"invalid position {payload.decode()}%, ignoring message",
),
]
def process_rocker_scene(self, scene: RockerScene):
if scene:
message = MQTTMessage()
message.payload = scene.command if isinstance(
scene.command, bytes) else scene.command.encode()
self._logger.debug("process rocker scene: %s", scene)
self.process_mqtt_message(message)
def continueDialog(self):
try:
siteId = request.form.get('siteId') if request.form.get(
'siteId',
None) is not None else self.ConfigManager.getAliceConfigByName(
'deviceName')
sessionId = request.form.get('sessionId')
session = self.DialogManager.getSession(sessionId=sessionId)
message = MQTTMessage()
message.payload = json.dumps({
'sessionId': session.sessionId,
'siteId': siteId,
'text': request.form.get('query')
})
session.extend(message=message)
self.MqttManager.publish(topic=constants.TOPIC_NLU_QUERY,
payload={
'input': request.form.get('query'),
'sessionId': session.sessionId,
'intentFilter': session.intentFilter
})
return jsonify(success=True, sessionId=session.sessionId)
except Exception as e:
self.logError(f'Failed processing: {e}')
return jsonify(success=False)
def test_mqtt_handle_on_message_delete_device_data(app_and_ctx, capsys):
device_id = 23
tid_bi = 'b209eba637a54f1f617cf5a6f925e4eb9fc083e66029061018b369e64b9864d7' # blind_index(hex_to_key("622c23fe2623e54ba103c13b88072ca3fdc5836fc459cb2b5c31d8df3f07ebc2"), "8")
topic = b"d:%a/server/remove_data" % device_id
payload = b"{'added': 6987, 'num_data': 31164, 'data': 'gAAAAABcTFAz9Wr5ZsnMcVYbQiXlnZCvT36MfDatZNyLwDpm_ixbzkZhM1NA4w7MN2p3CW3gyTA8gYtuKtDTomhulszvLTFfPA==', 'tid': 'encrypted_tid(8)', 'tid_bi': '%b', 'correctness_hash': '$2b$12$9hxKg4pjXbm0kpbItQTd2uMICAGn2ntRw1qQskHIL/7tLa3ISIlmO'}" % tid_bi.encode(
)
msg = MQTTMessage(topic=topic)
msg.payload = payload
from app.mqtt.mqtt import handle_on_message
app, ctx = app_and_ctx
with app.app_context():
device_data = db.session.query(DeviceData).filter(
and_(
DeviceData.tid_bi == tid_bi,
DeviceData.device_id == device_id,
)).first() # should be already present from previous test
assert device_data is not None, "Previous test probably failed to insert data."
handle_on_message(None, None, msg, app, db)
device_data = db.session.query(DeviceData).filter(
and_(
DeviceData.tid_bi == tid_bi,
DeviceData.device_id == device_id,
)).first()
assert device_data is None, "Data was not removed."
def test__mqtt_update_device_info_callback(
caplog: _pytest.logging.LogCaptureFixture,
topic_levels: typing.Tuple[_MQTTTopicLevel, ...],
topic: bytes,
expected_mac_address: str,
payload: bytes,
) -> None:
ActorMock = _mock_actor_class(request_info_levels=topic_levels)
message = MQTTMessage(topic=topic)
message.payload = payload
callback_userdata = _MQTTCallbackUserdata(
retry_count=21, # tested in test__mqtt_command_callback
device_passwords={},
fetch_device_info=True,
mqtt_topic_prefix="prfx/",
)
with unittest.mock.patch.object(
ActorMock, "__init__",
return_value=None) as init_mock, unittest.mock.patch.object(
ActorMock, "_update_and_report_device_info"
) as update_mock, caplog.at_level(logging.DEBUG):
ActorMock._mqtt_update_device_info_callback("client_dummy",
callback_userdata, message)
init_mock.assert_called_once_with(mac_address=expected_mac_address,
retry_count=21,
password=None)
update_mock.assert_called_once_with(mqtt_client="client_dummy",
mqtt_topic_prefix="prfx/")
assert caplog.record_tuples == [(
"switchbot_mqtt._actors.base",
logging.DEBUG,
f"received topic={topic.decode()} payload={payload!r}",
)]
async def on_message(self, message):
if message.author == self.client.user:
return
if self.client.user.mentioned_in(message):
async with message.channel.typing():
if message.channel.name in self.allowedChans:
try:
siteId = message.channel.name
sessionId = str(uuid.uuid4())
newMessage = MQTTMessage()
newMessage.payload = json.dumps({
'sessionId': sessionId,
'siteId': siteId
})
session = self.DialogSessionManager.addSession(
sessionId=sessionId, message=newMessage)
session.isAPIGenerated = True
self.MqttManager.publish(
topic=constants.TOPIC_NLU_QUERY,
payload={
'input':
message.content.replace(
"<@!" + str(self.client.user.id) + ">",
""),
'sessionId':
session.sessionId
})
except Exception as e:
self.logError(f'Failed processing: {e}')
else:
await message.channel.send(self.randomTalk("chanForbidden")
)
def test__mqtt_set_position_callback_command_failed(
caplog: _pytest.logging.LogCaptureFixture, ) -> None:
callback_userdata = _MQTTCallbackUserdata(
retry_count=3,
device_passwords={},
fetch_device_info=False,
mqtt_topic_prefix="",
)
message = MQTTMessage(
topic=b"cover/switchbot-curtain/aa:bb:cc:dd:ee:ff/position/set-percent"
)
message.payload = b"21"
with unittest.mock.patch(
"switchbot.SwitchbotCurtain") as device_init_mock, caplog.at_level(
logging.INFO):
device_init_mock().set_position.return_value = False
device_init_mock.reset_mock()
_CurtainMotor._mqtt_set_position_callback(mqtt_client="client dummy",
userdata=callback_userdata,
message=message)
device_init_mock.assert_called_once()
device_init_mock().set_position.assert_called_with(21)
assert caplog.record_tuples == [
(
"switchbot_mqtt._actors",
logging.ERROR,
"failed to set position of switchbot curtain aa:bb:cc:dd:ee:ff",
),
]
def test__mqtt_command_callback_ignore_retained(
caplog: _pytest.logging.LogCaptureFixture, topic: bytes,
payload: bytes) -> None:
ActorMock = _mock_actor_class(
command_topic_levels=_ButtonAutomator.MQTT_COMMAND_TOPIC_LEVELS)
message = MQTTMessage(topic=topic)
message.payload = payload
message.retain = True
with unittest.mock.patch.object(
ActorMock, "__init__",
return_value=None) as init_mock, unittest.mock.patch.object(
ActorMock,
"execute_command") as execute_command_mock, caplog.at_level(
logging.DEBUG):
ActorMock._mqtt_command_callback(
"client_dummy",
_MQTTCallbackUserdata(
retry_count=4,
device_passwords={},
fetch_device_info=True,
mqtt_topic_prefix="homeassistant/",
),
message,
)
init_mock.assert_not_called()
execute_command_mock.assert_not_called()
assert caplog.record_tuples == [
(
"switchbot_mqtt._actors.base",
logging.DEBUG,
f"received topic={topic.decode()} payload={payload!r}",
),
("switchbot_mqtt._actors.base", logging.INFO,
"ignoring retained message"),
]
def test__mqtt_set_position_callback_invalid_mac_address(
caplog: _pytest.logging.LogCaptureFixture, ) -> None:
callback_userdata = _MQTTCallbackUserdata(
retry_count=3,
device_passwords={},
fetch_device_info=False,
mqtt_topic_prefix="tnatsissaemoh/",
)
message = MQTTMessage(
topic=
b"tnatsissaemoh/cover/switchbot-curtain/aa:bb:cc:dd:ee/position/set-percent"
)
message.payload = b"42"
with unittest.mock.patch(
"switchbot.SwitchbotCurtain") as device_init_mock, caplog.at_level(
logging.INFO):
_CurtainMotor._mqtt_set_position_callback(mqtt_client="client dummy",
userdata=callback_userdata,
message=message)
device_init_mock.assert_not_called()
assert caplog.record_tuples == [
(
"switchbot_mqtt._actors.base",
logging.WARN,
"invalid mac address aa:bb:cc:dd:ee",
),
]
def test__mqtt_set_position_callback_ignore_retained(
caplog: _pytest.logging.LogCaptureFixture, ) -> None:
callback_userdata = _MQTTCallbackUserdata(
retry_count=3,
device_passwords={},
fetch_device_info=False,
mqtt_topic_prefix="whatever",
)
message = MQTTMessage(
topic=
b"homeassistant/cover/switchbot-curtain/aa:bb:cc:dd:ee:ff/position/set-percent"
)
message.payload = b"42"
message.retain = True
with unittest.mock.patch(
"switchbot.SwitchbotCurtain") as device_init_mock, caplog.at_level(
logging.INFO):
_CurtainMotor._mqtt_set_position_callback(mqtt_client="client dummy",
userdata=callback_userdata,
message=message)
device_init_mock.assert_not_called()
assert caplog.record_tuples == [
(
"switchbot_mqtt._actors",
logging.INFO,
"ignoring retained message on topic"
" homeassistant/cover/switchbot-curtain/aa:bb:cc:dd:ee:ff/position/set-percent",
),
]
def setUp(self):
self.ddm = DeviceDataManager()
self.ddm.actuator.addValue(15)
self.mqt = MqttClientConnector()
self.sd = SensorData()
self.sd.addValue(14)
mm = MQTTMessage()
mm.payload = "ss"
pass
def test_mqtt_handle_on_message_invalid_message(app_and_ctx, capsys):
msg = MQTTMessage(topic=b"anything")
msg.payload = b"invalid"
from app.mqtt.mqtt import handle_on_message
app, ctx = app_and_ctx
with app.app_context():
handle_on_message(None, None, msg, app, db)
captured = capsys.readouterr()
assert f"Received invalid message '" in captured.out
def private_publish(self, topic, payload=None, qos=0, retain=False):
"""
Queue message internally without distribute to MQTT.
"""
msg = MQTTMessage(topic=topic.encode())
msg.payload = payload.encode() if payload else None
msg.qos = qos
msg.retain = retain
self._queue.put(msg)
def process_mqtt_message_to_action(command) -> Fsr61Action:
message = MQTTMessage()
message.payload = command
device.packets.clear()
device.process_mqtt_message(message)
self.assertEqual(len(device.packets), 1)
return Fsr61Eep.extract_packet(device.packets[0])
def get_client_with_messages(msgs: dict) -> HomieClient:
c = HomieClient()
for topic, payload in msgs.items():
msg = MQTTMessage()
msg.topic = topic.encode('utf-8')
msg.payload = payload.encode('utf-8')
c.on_message(None, None, msg)
return c
def process_mqtt_message_to_command(mqtt_command) -> Fsb61Command:
message = MQTTMessage()
message.payload = mqtt_command
device.packets.clear()
device.process_mqtt_message(message)
self.assertEqual(len(device.packets), 1)
fsb61_command = Fsb61CommandConverter.extract_packet(
device.packets[0])
return fsb61_command
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 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 send_message(topic=None, payload=None):
# Mock an instance of an Eclipse Paho MQTTMessage
message = MQTTMessage(mid=42, topic=topic.encode('utf-8'))
message.payload = payload.encode('utf-8')
# Signal the message to the machinery
on_message(None, None, message)
# Give the machinery some time to process the message
time.sleep(0.05)
