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)