Tests n fixes (aws#16)

* Fixed memory leaks after structure changes in aws-c-io

* Added IoT service unit test

* Current state of IoT service test

* Revert "Fixed memory leaks after structure changes in aws-c-io"

This reverts commit 1b5ed8b961542c04721631bb7f7247e9af341720.

* Updated to mqtt version v0.3.2

* Made service test optional if certs don't exist

* clang-format

Author: justinboswell

aws-common-runtime/CMakeLists.txt

@@ -31,7 +31,7 @@ set(AWS_C_IO_SHA "v0.2.4")
 include(BuildAwsCIO)
 
 set(AWS_C_MQTT_URL "https://github.com/awslabs/aws-c-mqtt.git")
-set(AWS_C_MQTT_SHA "v0.3.1")
+set(AWS_C_MQTT_SHA "v0.3.2")
 include(BuildAwsCMqtt)
 
 set(AWS_C_CAL_URL "https://github.com/awslabs/aws-c-cal.git")

tests/CMakeLists.txt

@@ -17,6 +17,7 @@ add_test_case(BasicJsonParsing)
 add_test_case(SHA256ResourceSafety)
 add_test_case(MD5ResourceSafety)
 add_test_case(SHA256HMACResourceSafety)
+add_test_case(IotPublishSubscribe)
 
 generate_cpp_test_driver(${TEST_BINARY_NAME})
 

tests/IotServiceTest.cpp

@@ -0,0 +1,162 @@
+/*
+ * Copyright 2010-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ *  http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file is distributed
+ * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+#include <aws/crt/Api.h>
+
+#include <aws/testing/aws_test_harness.h>
+#include <utility>
+
+#include <condition_variable>
+#include <fstream>
+#include <mutex>
+
+#include <aws/io/logging.h>
+
+#define TEST_CERTIFICATE "/tmp/certificate.pem"
+#define TEST_PRIVATEKEY "/tmp/privatekey.pem"
+#define TEST_ROOTCA "/tmp/AmazonRootCA1.pem"
+
+static int s_TestIotPublishSubscribe(Aws::Crt::Allocator *allocator, void *ctx)
+{
+    using namespace Aws::Crt;
+    using namespace Aws::Crt::Io;
+    using namespace Aws::Crt::Mqtt;
+
+    const char *credentialFiles[] = {TEST_CERTIFICATE, TEST_PRIVATEKEY, TEST_ROOTCA};
+
+    for (int fileIdx = 0; fileIdx < AWS_ARRAY_SIZE(credentialFiles); ++fileIdx)
+    {
+        std::ifstream file;
+        file.open(credentialFiles[fileIdx]);
+        if (!file.is_open())
+        {
+            printf("Required credential file %s is missing or unreadable, skipping test\n", credentialFiles[fileIdx]);
+            return AWS_ERROR_SUCCESS;
+        }
+    }
+
+    (void)ctx;
+    Aws::Crt::ApiHandle apiHandle(allocator);
+
+    Aws::Crt::Io::TlsContextOptions tlsCtxOptions =
+        Aws::Crt::Io::TlsContextOptions::InitClientWithMtls(TEST_CERTIFICATE, TEST_PRIVATEKEY);
+    tlsCtxOptions.OverrideDefaultTrustStore(nullptr, TEST_ROOTCA);
+    Aws::Crt::Io::TlsContext tlsContext(tlsCtxOptions, Aws::Crt::Io::TlsMode::CLIENT, allocator);
+    ASSERT_TRUE(tlsContext);
+
+    Aws::Crt::Io::SocketOptions socketOptions;
+    AWS_ZERO_STRUCT(socketOptions);
+    socketOptions.type = AWS_SOCKET_STREAM;
+    socketOptions.domain = AWS_SOCKET_IPV4;
+    socketOptions.connect_timeout_ms = 3000;
+
+    Aws::Crt::Io::EventLoopGroup eventLoopGroup(0, allocator);
+    ASSERT_TRUE(eventLoopGroup);
+
+    Aws::Crt::Io::ClientBootstrap clientBootstrap(eventLoopGroup, allocator);
+    ASSERT_TRUE(allocator);
+
+    Aws::Crt::Mqtt::MqttClient mqttClient(clientBootstrap, allocator);
+    ASSERT_TRUE(mqttClient);
+
+    int tries = 0;
+    while (tries++ < 10)
+    {
+        auto mqttConnection = mqttClient.NewConnection(
+            "a16523t7iy5uyg-ats.iot.us-east-1.amazonaws.com", 8883, socketOptions, tlsContext.NewConnectionOptions());
+
+        std::mutex mutex;
+        std::condition_variable cv;
+        bool connected = false;
+        bool subscribed = false;
+        bool published = false;
+        bool received = false;
+        auto onConnectionCompleted =
+            [&](MqttConnection &connection, int errorCode, ReturnCode returnCode, bool sessionPresent) {
+                printf(
+                    "%s errorCode=%d returnCode=%d sessionPresent=%d\n",
+                    (errorCode == 0) ? "CONNECTED" : "COMPLETED",
+                    errorCode,
+                    (int)returnCode,
+                    (int)sessionPresent);
+                connected = true;
+                cv.notify_one();
+            };
+        auto onDisconnect = [&](MqttConnection &connection) {
+            printf("DISCONNECTED\n");
+            connected = false;
+            cv.notify_one();
+        };
+        auto onTest = [&](MqttConnection &connection, const String &topic, const ByteBuf &payload) {
+            printf("GOT MESSAGE topic=%s payload=" PRInSTR "\n", topic.c_str(), AWS_BYTE_BUF_PRI(payload));
+            received = true;
+            cv.notify_one();
+        };
+        auto onSubAck =
+            [&](MqttConnection &connection, uint16_t packetId, const String &topic, QOS qos, int errorCode) {
+                printf("SUBACK id=%d topic=%s qos=%d\n", packetId, topic.c_str(), qos);
+                subscribed = true;
+                cv.notify_one();
+            };
+        auto onPubAck = [&](MqttConnection &connection, uint16_t packetId, int errorCode) {
+            printf("PUBLISHED id=%d\n", packetId);
+            published = true;
+            cv.notify_one();
+        };
+
+        mqttConnection->OnConnectionCompleted = onConnectionCompleted;
+        mqttConnection->OnDisconnect = onDisconnect;
+        char clientId[32];
+        sprintf(clientId, "aws-crt-cpp-v2-%d", tries);
+        mqttConnection->Connect(clientId, true);
+
+        {
+            std::unique_lock<std::mutex> lock(mutex);
+            cv.wait(lock, [&]() { return connected; });
+        }
+
+        mqttConnection->Subscribe("/publish/me/senpai", QOS::AWS_MQTT_QOS_AT_LEAST_ONCE, onTest, onSubAck);
+
+        {
+            std::unique_lock<std::mutex> lock(mutex);
+            cv.wait(lock, [&]() { return subscribed; });
+        }
+
+        Aws::Crt::ByteBuf payload = Aws::Crt::ByteBufFromCString("notice me pls");
+        mqttConnection->Publish("/publish/me/senpai", QOS::AWS_MQTT_QOS_AT_LEAST_ONCE, false, payload, onPubAck);
+
+        // wait for publish
+        {
+            std::unique_lock<std::mutex> lock(mutex);
+            cv.wait(lock, [&]() { return published; });
+        }
+
+        // wait for message received callback
+        {
+            std::unique_lock<std::mutex> lock(mutex);
+            cv.wait(lock, [&]() { return received; });
+        }
+
+        mqttConnection->Disconnect();
+        {
+            std::unique_lock<std::mutex> lock(mutex);
+            cv.wait(lock, [&]() { return !connected; });
+        }
+        ASSERT_TRUE(mqttConnection);
+    }
+
+    return AWS_ERROR_SUCCESS;
+}
+
+AWS_TEST_CASE(IotPublishSubscribe, s_TestIotPublishSubscribe)