mqtt_new.cpp

00001 /*
00002  * Copyright (c) 2019, ARM Limited, All Rights Reserved
00003  * SPDX-License-Identifier: Apache-2.0
00004  *
00005  * Licensed under the Apache License, Version 2.0 (the "License"); you may
00006  * not use this file except in compliance with the License.
00007  * You may obtain a copy of the License at
00008  *
00009  * http://www.apache.org/licenses/LICENSE-2.0
00010  *
00011  * Unless required by applicable law or agreed to in writing, software
00012  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
00013  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00014  * See the License for the specific language governing permissions and
00015  * limitations under the License.
00016  */
00017 
00018 #include <MQTTClientMbedOs.h>
00019 #include "mqtt_tests.h"
00020 #include "unity/unity.h"
00021 
00022 #define MQTT_API_INIT() \
00023     arrivedcount = 0; \
00024     NetworkInterface *net = NetworkInterface::get_default_instance(); \
00025     TCPSocket socket; \
00026     SocketAddress addr; \
00027     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, socket.open(net)); \
00028     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, net->gethostbyname(mqtt_global::hostname, &addr)); \
00029     addr.set_port(mqtt_global::port); \
00030     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, socket.connect(addr)); \
00031     MQTTClient client(&socket); \
00032     MQTTPacket_connectData data = MQTTPacket_connectData_initializer; \
00033     MQTT_API_ATTACH_USERNAME_PASSWORD() \
00034     data.MQTTVersion = 3;
00035 
00036 #define MQTT_API_DEINIT() \
00037         TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, socket.close());
00038 
00039 void MQTT_CONNECT()
00040 {
00041     MQTT_API_INIT();
00042     data.clientID.cstring = (char *)"MQTT_CONNECT";
00043     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.connect(data));
00044     MQTT_API_DEINIT();
00045 }
00046 
00047 void MQTT_CONNECT_NOT_CONNECTED()
00048 {
00049     NetworkInterface *net = NetworkInterface::get_default_instance();
00050     SocketAddress sockAddr(mqtt_global::hostname, mqtt_global::port);
00051     TCPSocket socket;
00052     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, socket.open(net));
00053     MQTTClient client(&socket);
00054     MQTTPacket_connectData data = MQTTPacket_connectData_initializer;
00055     TEST_ASSERT_EQUAL(NSAPI_ERROR_NO_CONNECTION, client.connect(data));
00056 }
00057 
00058 void MQTT_SUBSCRIBE()
00059 {
00060     MQTT_API_INIT();
00061     data.clientID.cstring = (char *)"MQTT_SUBSCRIBE";
00062     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.connect(data));
00063     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.subscribe(mqtt_global::topic, MQTT::QOS0, messageArrived));
00064     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.subscribe(mqtt_global::topic, MQTT::QOS1, messageArrived));
00065     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.subscribe(mqtt_global::topic, MQTT::QOS2, messageArrived));
00066     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.unsubscribe(mqtt_global::topic));
00067     MQTT_API_DEINIT();
00068 
00069 }
00070 
00071 void MQTT_SUBSCRIBE_NETWORK_NOT_CONNECTED()
00072 {
00073     NetworkInterface *net = NetworkInterface::get_default_instance();
00074     TCPSocket socket;
00075     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, socket.open(net));
00076     SocketAddress addr; // intentionally empty
00077     TEST_ASSERT_NOT_EQUAL(NSAPI_ERROR_OK, socket.connect(addr));
00078     MQTTClient client(&socket);
00079     MQTTPacket_connectData data = MQTTPacket_connectData_initializer;
00080     data.MQTTVersion = 3;
00081     data.clientID.cstring = (char *)"MQTT_SUBSCRIBE_NETWORK_NOT_CONNECTED";
00082     TEST_ASSERT_EQUAL(NSAPI_ERROR_NO_CONNECTION, client.connect(data));
00083     TEST_ASSERT_EQUAL(NSAPI_ERROR_NO_CONNECTION, client.subscribe(mqtt_global::topic, MQTT::QOS0, messageArrived));
00084 }
00085 
00086 void MQTT_SUBSCRIBE_CLIENT_NOT_CONNECTED()
00087 {
00088     MQTT_API_INIT();
00089     TEST_ASSERT_EQUAL(NSAPI_ERROR_NO_CONNECTION, client.subscribe(mqtt_global::topic, MQTT::QOS0, messageArrived));
00090     MQTT_API_DEINIT();
00091 }
00092 
00093 void MQTT_SUBSCRIBE_TOPIC_TOO_LONG()
00094 {
00095     MQTT_API_INIT();
00096     data.clientID.cstring = (char *)"MQTT_SUBSCRIBE_TOPIC_TOO_LONG";
00097     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.connect(data));
00098     TEST_ASSERT_EQUAL(NSAPI_ERROR_NO_CONNECTION, client.subscribe(mqtt_global::topic_too_long, MQTT::QOS0, messageArrived));
00099     MQTT_API_DEINIT();
00100 }
00101 
00102 void MQTT_SUBSCRIBE_INVALID_MESSAGE_HANDLER()
00103 {
00104     MQTT_API_INIT();
00105     data.clientID.cstring = (char *)"MQTT_SUBSCRIBE_INVALID_MESSAGE_HANDLER";
00106     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.connect(data));
00107     TEST_ASSERT_EQUAL(NSAPI_ERROR_NO_CONNECTION, client.subscribe(mqtt_global::topic, MQTT::QOS0, NULL));
00108     MQTT_API_DEINIT();
00109 }
00110 
00111 void MQTT_SUBSCRIBE_RECEIVE()
00112 {
00113     MQTT_API_INIT();
00114     data.clientID.cstring = (char *)"MQTT_SUBSCRIBE_INVALID_MESSAGE_HANDLER";
00115     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.connect(data));
00116     int arrivedCountBeforeSubscription = arrivedcount;
00117     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.subscribe(mqtt_global::mbed_public_test_topic, MQTT::QOS0, messageArrived));
00118     while (arrivedCountBeforeSubscription == arrivedcount) {
00119         client.yield(100);
00120     }
00121     TEST_ASSERT_TRUE(arrivedCountBeforeSubscription < arrivedcount);
00122     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.unsubscribe(mqtt_global::mbed_public_test_topic));
00123     MQTT_API_DEINIT();
00124 }
00125 
00126 void MQTT_UNSUBSCRIBE_WITHOUT_SUBSCRIBE()
00127 {
00128     MQTT_API_INIT();
00129     data.clientID.cstring = (char *)"MQTT_UNSUBSCRIBE_WITHOUT_SUBSCRIBE";
00130     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.connect(data));
00131     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.unsubscribe(mqtt_global::topic));
00132     MQTT_API_DEINIT();
00133 }
00134 
00135 void MQTT_UNSUBSCRIBE_INVALID()
00136 {
00137     MQTT_API_INIT();
00138     data.clientID.cstring = (char *)"MQTT_UNSUBSCRIBE_INVALID";
00139     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.connect(data));
00140     TEST_ASSERT_EQUAL(NSAPI_ERROR_NO_CONNECTION, client.unsubscribe(""));
00141     TEST_ASSERT_EQUAL(NSAPI_ERROR_NO_CONNECTION, client.unsubscribe(mqtt_global::topic_too_long));
00142     MQTT_API_DEINIT();
00143 }
00144 
00145 void MQTT_PUBLISH()
00146 {
00147     MQTT_API_INIT();
00148     data.clientID.cstring = (char *)"MQTT_PUBLISH";
00149     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.connect(data));
00150     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.publish(mqtt_global::topic, mqtt_global::default_message));
00151     MQTT::Message msg = mqtt_global::default_message;
00152     msg.qos = MQTT::QOS1;
00153     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.publish(mqtt_global::topic, msg));
00154     msg.qos = MQTT::QOS2;
00155     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.publish(mqtt_global::topic, msg));
00156     MQTT_API_DEINIT();
00157 }
00158 
00159 void MQTT_PUBLISH_NOT_CONNECTED()
00160 {
00161     MQTT_API_INIT();
00162     TEST_ASSERT_EQUAL(NSAPI_ERROR_NO_CONNECTION, client.publish(mqtt_global::topic, mqtt_global::default_message));
00163     MQTT_API_DEINIT();
00164 }
00165 
00166 void MQTT_PUBLISH_TOPIC_TOO_LONG()
00167 {
00168     MQTT_API_INIT();
00169     data.clientID.cstring = (char *)"MQTT_PUBLISH";
00170     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.connect(data));
00171     // TODO verify if this is passing intentionally or if this is a bug?
00172 //    TEST_ASSERT_EQUAL(-1, client.publish(mqtt_global::topic_too_long, mqtt_global::default_message));
00173     MQTT_API_DEINIT();
00174 }
00175 
00176 void MQTT_CONNECT_USER_PASSWORD_INCORRECT()
00177 {
00178     MQTT_API_INIT();
00179     data.MQTTVersion = 3;
00180     data.clientID.cstring = (char *)"MQTT_CONNECT_USER_PASSWORD_INCORRECT";
00181     data.username.cstring = (char *)"wronguser";
00182     data.password.cstring = (char *)"wrongpassword";
00183     TEST_ASSERT_NOT_EQUAL(NSAPI_ERROR_OK, client.connect(data));
00184     // Sending works. The retval from MQTTDeserialize_connack (5) is returned... Bug?
00185     MQTT_API_DEINIT();
00186 }
00187 
00188 void MQTT_CONNECT_SUBSCRIBE_PUBLISH()
00189 {
00190     NetworkInterface *net = NetworkInterface::get_default_instance();
00191     TCPSocket socket;
00192     socket.open(net);
00193     SocketAddress addr;
00194     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, net->gethostbyname(mqtt_global::hostname, &addr));
00195     addr.set_port(mqtt_global::port);
00196     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, socket.connect(addr));
00197     socket.connect(addr);
00198 
00199     MQTTClient client(&socket);
00200 
00201     send_messages<MQTTClient>(client, "MQTT_CONNECT_SUBSCRIBE_PUBLISH");
00202 
00203     socket.close();
00204 }
00205 #if defined(MBEDTLS_SSL_CLI_C)
00206 void MQTT_TLS_CONNECT_SUBSCRIBE_PUBLISH()
00207 {
00208     NetworkInterface *net = NetworkInterface::get_default_instance();
00209     TLSSocket *socket = new TLSSocket; // Allocate on heap to avoid stack overflow.
00210     TEST_ASSERT(NSAPI_ERROR_OK == socket->open(net));
00211     TEST_ASSERT(NSAPI_ERROR_OK == socket->set_root_ca_cert(mqtt_global::SSL_CA_PEM));
00212     SocketAddress addr;
00213     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, net->gethostbyname(mqtt_global::hostname, &addr));
00214     addr.set_port(mqtt_global::port_tls);
00215     int ret = socket->connect(addr);
00216     TEST_ASSERT(NSAPI_ERROR_OK == ret);
00217 
00218     MQTTClient client(socket);
00219 
00220     send_messages<MQTTClient>(client, "MQTT_TLS_CONNECT_SUBSCRIBE_PUBLISH");
00221 
00222     socket->close();
00223     delete socket;
00224 }
00225 #endif
00226 
00227 void MQTT_CONNECT_SUBSCRIBE_PUBLISH_USER_PASSWORD()
00228 {
00229     NetworkInterface *net = NetworkInterface::get_default_instance();
00230     TCPSocket socket;
00231     socket.open(net);
00232     SocketAddress addr;
00233     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, net->gethostbyname(mqtt_global::hostname, &addr));
00234     addr.set_port(mqtt_global::port);
00235     socket.connect(addr);
00236 
00237     MQTTClient client(&socket);
00238 
00239     send_messages<MQTTClient>(client, "MQTT_CONNECT_SUBSCRIBE_PUBLISH_USER_PASSWORD");
00240 
00241     socket.close();
00242 }