mqtt-sn_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 "mqtt_tests.h"
00019 
00020 #include <MQTTClientMbedOs.h>
00021 
00022 #define MQTTSN_API_INIT() \
00023     arrivedcountSN = 0; \
00024     NetworkInterface *net = NetworkInterface::get_default_instance(); \
00025     SocketAddress sockAddr; \
00026     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, net->gethostbyname(mqtt_global::hostname, &sockAddr)); \
00027     sockAddr.set_port(mqtt_global::port_udp); \
00028     UDPSocket socket; \
00029     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, socket.open(net)); \
00030     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, socket.connect(sockAddr)); \
00031     MQTTClient client(&socket); \
00032     MQTTSNPacket_connectData data = MQTTSNPacket_connectData_initializer;
00033 
00034 #define MQTTSN_API_DEINIT() \
00035         TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, socket.close());\
00036 
00037 void MQTTSN_TEST_CONNECT()
00038 {
00039     MQTTSN_API_INIT();
00040     data.clientID.cstring = (char *)"MQTTSN_CONNECT";
00041     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.connect(data));
00042     MQTTSN_API_DEINIT();
00043 }
00044 
00045 void MQTTSN_CONNECT_NOT_CONNECTED()
00046 {
00047     NetworkInterface *net = NetworkInterface::get_default_instance();
00048     SocketAddress sockAddr("i.dont.exist", mqtt_global::port_udp);
00049     UDPSocket socket;
00050     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, socket.open(net));
00051 
00052     //Connect in UDP is not real, it will return success...
00053     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, socket.connect(sockAddr));
00054     MQTTClient client(&socket);
00055     MQTTSNPacket_connectData data = MQTTSNPacket_connectData_initializer;
00056 
00057     //... but we should not be able to connect to the server.
00058     TEST_ASSERT_EQUAL(NSAPI_ERROR_NO_CONNECTION, client.connect(data));
00059 }
00060 
00061 void MQTTSN_TEST_SUBSCRIBE()
00062 {
00063     MQTTSN_API_INIT();
00064     data.clientID.cstring = (char *)"MQTTSN_TEST_SUBSCRIBE";
00065     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.connect(data));
00066     MQTTSN_topicid topic_sn;
00067     init_topic_sn(topic_sn);
00068     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.subscribe(topic_sn, MQTTSN::QOS0, messageArrivedSN));
00069     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.unsubscribe(topic_sn));
00070     init_topic_sn(topic_sn);
00071     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.subscribe(topic_sn, MQTTSN::QOS1, messageArrivedSN));
00072     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.unsubscribe(topic_sn));
00073     init_topic_sn(topic_sn);
00074     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.subscribe(topic_sn, MQTTSN::QOS2, messageArrivedSN));
00075     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.unsubscribe(topic_sn));
00076     MQTTSN_API_DEINIT();
00077 
00078 }
00079 
00080 void MQTTSN_SUBSCRIBE_NETWORK_NOT_CONNECTED()
00081 {
00082     NetworkInterface *net = NetworkInterface::get_default_instance();
00083     SocketAddress sockAddr("i.dont.exist", mqtt_global::port_udp);
00084     UDPSocket socket;
00085     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, socket.open(net));
00086 
00087     //Connect in UDP is not real, it will return success...
00088     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, socket.connect(sockAddr));
00089     MQTTClient client(&socket);
00090     MQTTSNPacket_connectData data = MQTTSNPacket_connectData_initializer;
00091     data.clientID.cstring = (char *)"MQTTSN_SUBSCRIBE_NETWORK_NOT_CONNECTED";
00092     // ... but the connect should fail ...
00093     TEST_ASSERT_EQUAL(NSAPI_ERROR_NO_CONNECTION, client.connect(data));
00094     MQTTSN_topicid topic_sn;
00095     init_topic_sn(topic_sn);
00096     // ... and subscribe should also fail.
00097     TEST_ASSERT_EQUAL(NSAPI_ERROR_NO_CONNECTION, client.subscribe(topic_sn, MQTTSN::QOS0, messageArrivedSN));
00098 }
00099 
00100 void MQTTSN_SUBSCRIBE_CLIENT_NOT_CONNECTED()
00101 {
00102     MQTTSN_API_INIT();
00103     data.clientID.cstring = (char *)"12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890";
00104     MQTTSN_topicid topic_sn;
00105     init_topic_sn(topic_sn);
00106     TEST_ASSERT_EQUAL(NSAPI_ERROR_NO_CONNECTION, client.connect(data));
00107     TEST_ASSERT_EQUAL(NSAPI_ERROR_NO_CONNECTION, client.subscribe(topic_sn, MQTTSN::QOS0, messageArrivedSN));
00108     MQTTSN_API_DEINIT();
00109 }
00110 
00111 void MQTTSN_SUBSCRIBE_TOPIC_TOO_LONG()
00112 {
00113     MQTTSN_API_INIT();
00114     data.clientID.cstring = (char *)"MQTTSN_SUBSCRIBE_TOPIC_TOO_LONG";
00115     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.connect(data));
00116     MQTTSN_topicid topic_sn;
00117     init_topic_sn_too_long(topic_sn);
00118     TEST_ASSERT_EQUAL(NSAPI_ERROR_NO_CONNECTION, client.subscribe(topic_sn, MQTTSN::QOS0, messageArrivedSN));
00119     MQTTSN_API_DEINIT();
00120 }
00121 
00122 void MQTTSN_SUBSCRIBE_INVALID_MESSAGE_HANDLER()
00123 {
00124     MQTTSN_API_INIT();
00125     data.clientID.cstring = (char *)"MQTTSN_SUBSCRIBE_INVALID_MESSAGE_HANDLER";
00126     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.connect(data));
00127     MQTTSN_topicid topic_sn;
00128     init_topic_sn(topic_sn);
00129     // There is no NULL check inside the subscribe function.
00130 //    TEST_ASSERT_EQUAL(-1, client.subscribe(topic_sn, MQTTSN::QOS0, NULL));
00131     MQTTSN_API_DEINIT();
00132 }
00133 
00134 void MQTTSN_SUBSCRIBE_RECEIVE()
00135 {
00136     MQTTSN_API_INIT();
00137     data.clientID.cstring = (char *)"MQTTSN_SUBSCRIBE_INVALID_MESSAGE_HANDLER";
00138     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.connect(data));
00139     int arrivedCountBeforeSubscription = arrivedcountSN;
00140     MQTTSN_topicid topic_sn;
00141     topic_sn.type = MQTTSN_TOPIC_TYPE_NORMAL;
00142     topic_sn.data.long_.len = strlen(mqtt_global::mbed_public_test_topic);
00143     topic_sn.data.long_.name = const_cast<char *>(mqtt_global::mbed_public_test_topic);
00144     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.subscribe(topic_sn, MQTTSN::QOS0, messageArrivedSN));
00145     // TODO get the callbacks working for MQTT-SN
00146     while (arrivedCountBeforeSubscription == arrivedcountSN) {
00147         client.yield(100);
00148     }
00149     TEST_ASSERT_TRUE(arrivedCountBeforeSubscription < arrivedcountSN);
00150     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.unsubscribe(topic_sn));
00151     MQTTSN_API_DEINIT();
00152 }
00153 
00154 void MQTTSN_UNSUBSCRIBE_WITHOUT_SUBSCRIBE()
00155 {
00156     MQTTSN_API_INIT();
00157     data.clientID.cstring = (char *)"MQTTSN_UNSUBSCRIBE_WITHOUT_SUBSCRIBE";
00158     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.connect(data));
00159     MQTTSN_topicid topic_sn;
00160     init_topic_sn(topic_sn);
00161     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.unsubscribe(topic_sn));
00162     MQTTSN_API_DEINIT();
00163 }
00164 
00165 void MQTTSN_UNSUBSCRIBE_INVALID()
00166 {
00167     MQTTSN_API_INIT();
00168     data.clientID.cstring = (char *)"MQTTSN_UNSUBSCRIBE_INVALID";
00169     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.connect(data));
00170     MQTTSN_topicid topic_sn_too_long;
00171     init_topic_sn_too_long(topic_sn_too_long);
00172     TEST_ASSERT_EQUAL(NSAPI_ERROR_NO_CONNECTION, client.unsubscribe(topic_sn_too_long));
00173     MQTTSN_API_DEINIT();
00174 }
00175 
00176 void MQTTSN_TEST_PUBLISH()
00177 {
00178     MQTTSN_API_INIT();
00179     data.clientID.cstring = (char *)"MQTTSN_PUBLISH";
00180     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.connect(data));
00181     MQTTSN_topicid topic_sn;
00182     init_topic_sn(topic_sn);
00183     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.publish(topic_sn, mqtt_global::default_message_sn));
00184     MQTTSN::Message msg = mqtt_global::default_message_sn;
00185     msg.qos = MQTTSN::QOS1;
00186     // TODO: get QoS 1 and 2 working. Maybe we need to reconnect?
00187 //    TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.publish(topic_sn, msg));
00188 //    msg.qos = MQTTSN::QOS2;
00189 //    TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.publish(topic_sn, msg));
00190     MQTTSN_API_DEINIT();
00191 }
00192 
00193 void MQTTSN_PUBLISH_NOT_CONNECTED()
00194 {
00195     MQTTSN_API_INIT();
00196     MQTTSN_topicid topic_sn;
00197     init_topic_sn(topic_sn);
00198     TEST_ASSERT_EQUAL(NSAPI_ERROR_NO_CONNECTION, client.publish(topic_sn, mqtt_global::default_message_sn));
00199     MQTTSN_API_DEINIT();
00200 }
00201 
00202 void MQTTSN_PUBLISH_TOPIC_TOO_LONG()
00203 {
00204     MQTTSN_API_INIT();
00205     data.clientID.cstring = (char *)"MQTT_PUBLISH";
00206     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.connect(data));
00207     // TODO verify if this is passing intentionally or if this is a bug?
00208 //    TEST_ASSERT_EQUAL(-1, client.publish(mqtt_global::topic_too_long, mqtt_global::default_message));
00209     MQTTSN_API_DEINIT();
00210 }
00211 
00212 // QTT-SN does not provide the user/password functionality so
00213 // MQTT_CONNECT_USER_PASSWORD_INCORRECT and MQTT_CONNECT_SUBSCRIBE_PUBLISH_USER_PASSWORD
00214 // cannot be executed for MQTT-SN
00215 
00216 void MQTTSN_IS_CONNECTED()
00217 {
00218     MQTTSN_API_INIT();
00219     data.clientID.cstring = (char *)"MQTTSN_IS_CONNECTED";
00220     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, client.connect(data));
00221     TEST_ASSERT_TRUE(client.isConnected());
00222     MQTTSN_API_DEINIT();
00223 }
00224 
00225 void MQTTSN_IS_CONNECTED_CLIENT_NOT_CONNECTED()
00226 {
00227     MQTTSN_API_INIT();
00228     TEST_ASSERT_FALSE(client.isConnected());
00229     MQTTSN_API_DEINIT();
00230 }
00231 
00232 void MQTTSN_IS_CONNECTED_NETWORK_NOT_CONNECTED()
00233 {
00234     NetworkInterface *net = NetworkInterface::get_default_instance();
00235     SocketAddress sockAddr("i.dont.exist", mqtt_global::port_udp);
00236     UDPSocket socket;
00237     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, socket.open(net));
00238 
00239     //Connect in UDP is not real, it will return success...
00240     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, socket.connect(sockAddr));
00241     MQTTClient client(&socket);
00242     MQTTSNPacket_connectData data = MQTTSNPacket_connectData_initializer;
00243     data.clientID.cstring = (char *)"MQTTSN_IS_CONNECTED_NETWORK_NOT_CONNECTED";
00244 
00245     TEST_ASSERT_FALSE(client.isConnected());
00246 
00247     // ... but the connect should fail ...
00248     TEST_ASSERT_EQUAL(NSAPI_ERROR_NO_CONNECTION, client.connect(data));
00249 
00250     TEST_ASSERT_FALSE(client.isConnected());
00251 }
00252 
00253 void MQTTSN_UDP_CONNECT_SUBSCRIBE_PUBLISH()
00254 {
00255     NetworkInterface *net = NetworkInterface::get_default_instance();
00256     SocketAddress sockAddr(mqtt_global::hostname, mqtt_global::port_udp);
00257     UDPSocket socket;
00258     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, socket.open(net));
00259     TEST_ASSERT(NSAPI_ERROR_OK == socket.connect(sockAddr));
00260     MQTTClient client(&socket);
00261 
00262     send_messages_sn< MQTTClient >(client, "MQTT_FULL_NEW_UDP");
00263 
00264     socket.close();
00265 }
00266 
00267 #if defined(MBEDTLS_SSL_CLI_C)
00268 void MQTTSN_DTLS_CONNECT_SUBSCRIBE_PUBLISH()
00269 {
00270     NetworkInterface *net = NetworkInterface::get_default_instance();
00271     DTLSSocket *socket = new DTLSSocket; // Allocate on heap to avoid stack overflow.
00272     TEST_ASSERT(NSAPI_ERROR_OK == socket->open(net));
00273     SocketAddress addr;
00274     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, net->gethostbyname(mqtt_global::hostname, &addr));
00275     addr.set_port(mqtt_global::port_udp);
00276     TEST_ASSERT(NSAPI_ERROR_OK == socket->set_root_ca_cert(mqtt_global::SSL_CA_PEM));
00277     int ret = socket->connect(addr);
00278     TEST_ASSERT(NSAPI_ERROR_OK == ret);
00279 
00280     MQTTClient client(socket);
00281 
00282     send_messages_sn< MQTTClient >(client, "MQTTSN_DTLS_CONNECT_SUBSCRIBE_PUBLISH");
00283 
00284     socket->close();
00285     delete socket;
00286 }
00287 #endif