Add configuration mocking code

mfontanini · mfontanini · commit 7aedcdc30fa2 · 2017-10-16T21:12:10.000-07:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -40,6 +40,7 @@ find_package(Boost REQUIRED)
 find_package(RdKafka REQUIRED)
 
 add_subdirectory(src)
+add_subdirectory(mocking)
 add_subdirectory(include)
 
 add_subdirectory(examples)
@@ -95,4 +96,4 @@ configure_file(
 
 # Add uninstall target
 add_custom_target(uninstall
-    COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake)
+    COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake)
diff --git a/include/cppkafka/clonable_ptr.h b/include/cppkafka/clonable_ptr.h
@@ -84,6 +84,13 @@ class ClonablePtr {
     T* get() const {
         return handle_.get();
     }
+
+    /**
+     * Resets the internal pointer
+     */
+    void reset(T* ptr) {
+        handle_.reset(ptr);
+    }
 private:
     std::unique_ptr<T, Deleter> handle_;
     Cloner cloner_;
diff --git a/mocking/CMakeLists.txt b/mocking/CMakeLists.txt
@@ -0,0 +1 @@
+add_subdirectory(src)
diff --git a/mocking/include/cppkafka/mocking/api.h b/mocking/include/cppkafka/mocking/api.h
@@ -0,0 +1,74 @@
+#ifndef CPPKAFKA_MOCKING_API_H
+#define CPPKAFKA_MOCKING_API_H
+
+#include <librdkafka/rdkafka.h>
+#include <cppkafka/mocking/handle_wrapper.h>
+#include <cppkafka/mocking/configuration_mock.h>
+#include <cppkafka/macros.h>
+
+struct rd_kafka_conf_s : cppkafka::mocking::HandleWrapper<cppkafka::mocking::ConfigurationMock> {
+    using cppkafka::mocking::HandleWrapper<cppkafka::mocking::ConfigurationMock>::HandleWrapper;
+};
+
+struct rd_kafka_topic_conf_s : rd_kafka_conf_s {
+    using rd_kafka_conf_s::rd_kafka_conf_s;
+};
+
+// rd_kafka_conf_t
+CPPKAFKA_API rd_kafka_conf_t* rd_kafka_conf_new();
+CPPKAFKA_API void rd_kafka_conf_destroy(rd_kafka_conf_t* conf);
+CPPKAFKA_API rd_kafka_conf_t* rd_kafka_conf_dup(const rd_kafka_conf_t* conf);
+CPPKAFKA_API rd_kafka_conf_res_t rd_kafka_conf_set(rd_kafka_conf_t* conf,
+                                                   const char* name, const char* value,
+                                                   char* errstr, size_t errstr_size);
+CPPKAFKA_API rd_kafka_conf_res_t rd_kafka_conf_get(const rd_kafka_conf_t* conf,
+                                                   const char* name, char* dest,
+                                                   size_t* dest_size);
+CPPKAFKA_API
+void rd_kafka_conf_set_dr_msg_cb(rd_kafka_conf_t* conf,
+                                 cppkafka::mocking::ConfigurationMock::DeliveryReportCallback* cb);
+CPPKAFKA_API
+void rd_kafka_conf_set_rebalance_cb(rd_kafka_conf_t* conf,
+                                    cppkafka::mocking::ConfigurationMock::RebalanceCallback* cb);
+CPPKAFKA_API
+void rd_kafka_conf_set_offset_commit_cb(rd_kafka_conf_t* conf,
+                                    cppkafka::mocking::ConfigurationMock::OffsetCommitCallback* cb);
+CPPKAFKA_API
+void rd_kafka_conf_set_error_cb(rd_kafka_conf_t* conf,
+                                cppkafka::mocking::ConfigurationMock::ErrorCallback* cb);
+CPPKAFKA_API
+void rd_kafka_conf_set_throttle_cb(rd_kafka_conf_t* conf,
+                                   cppkafka::mocking::ConfigurationMock::ThrottleCallback* cb);
+CPPKAFKA_API
+void rd_kafka_conf_set_log_cb(rd_kafka_conf_t* conf,
+                              cppkafka::mocking::ConfigurationMock::LogCallback* cb);
+CPPKAFKA_API
+void rd_kafka_conf_set_stats_cb(rd_kafka_conf_t* conf,
+                                cppkafka::mocking::ConfigurationMock::StatsCallback* cb);
+CPPKAFKA_API
+void rd_kafka_conf_set_socket_cb(rd_kafka_conf_t* conf,
+                                 cppkafka::mocking::ConfigurationMock::SocketCallback* cb);
+CPPKAFKA_API
+void rd_kafka_topic_conf_set_partitioner_cb(rd_kafka_conf_t* conf,
+                                    cppkafka::mocking::ConfigurationMock::PartitionerCallback* cb);
+CPPKAFKA_API
+void rd_kafka_conf_set_default_topic_conf(rd_kafka_conf_t* conf,
+                                          rd_kafka_topic_conf_t* tconf);
+CPPKAFKA_API void rd_kafka_conf_set_opaque(rd_kafka_conf_t* conf, void* opaque);
+CPPKAFKA_API const char** rd_kafka_conf_dump(rd_kafka_conf_t* conf, size_t* cntp);
+CPPKAFKA_API void rd_kafka_conf_dump_free(const char** arr, size_t cnt);
+
+// rd_kafka_topic_conf_t
+CPPKAFKA_API rd_kafka_topic_conf_t* rd_kafka_topic_conf_new();
+CPPKAFKA_API void rd_kafka_topic_conf_destroy(rd_kafka_topic_conf_t* conf);
+CPPKAFKA_API rd_kafka_topic_conf_t* rd_kafka_topic_conf_dup(const rd_kafka_topic_conf_t* conf);
+CPPKAFKA_API rd_kafka_conf_res_t rd_kafka_topic_conf_set(rd_kafka_topic_conf_t* conf,
+                                                         const char* name, const char* value,
+                                                         char* errstr, size_t errstr_size);
+CPPKAFKA_API rd_kafka_conf_res_t rd_kafka_topic_conf_get(const rd_kafka_topic_conf_t *conf,
+                                                         const char *name, char *dest,
+                                                         size_t *dest_size);
+CPPKAFKA_API
+const char** rd_kafka_topic_conf_dump(rd_kafka_topic_conf_t* conf, size_t* cntp);
+
+#endif // CPPKAFKA_MOCKING_API_H
diff --git a/mocking/include/cppkafka/mocking/configuration_mock.h b/mocking/include/cppkafka/mocking/configuration_mock.h
@@ -0,0 +1,100 @@
+#ifndef CPPKAFKA_MOCKING_CONFIGURATION_MOCK_H
+#define CPPKAFKA_MOCKING_CONFIGURATION_MOCK_H
+
+#include <librdkafka/rdkafka.h>
+#include <unordered_map>
+#include <string>
+#include <cppkafka/clonable_ptr.h>
+
+namespace cppkafka {
+namespace mocking {
+
+class ConfigurationMock {
+public:
+    using DeliveryReportCallback = void(rd_kafka_t*, const rd_kafka_message_t*, void *);
+    using RebalanceCallback = void(rd_kafka_t*, rd_kafka_resp_err_t,
+                                   rd_kafka_topic_partition_list_t*, void*);
+    using OffsetCommitCallback = void(rd_kafka_t*, rd_kafka_resp_err_t,
+                                      rd_kafka_topic_partition_list_t*, void*);
+    using ErrorCallback = void(rd_kafka_t*, int, const char*, void*);
+    using ThrottleCallback = void(rd_kafka_t*, const char*, int32_t, int, void*);
+    using LogCallback = void(const rd_kafka_t*, int, const char*, const char*);
+    using StatsCallback = int(rd_kafka_t*, char*, size_t, void*);
+    using SocketCallback = int(int, int, int, void*);
+    using PartitionerCallback = int32_t(const rd_kafka_topic_t*, const void*,
+                                        size_t, int32_t, void*, void*);
+
+    ConfigurationMock();
+
+    void set(std::string key, std::string value);
+    size_t has_key(const std::string& key) const;
+    std::string get(const std::string& key) const;
+
+    void set_delivery_report_callback(DeliveryReportCallback* callback);
+    void set_rebalance_callback(RebalanceCallback* callback);
+    void set_offset_commit_callback(OffsetCommitCallback* callback);
+    void set_error_callback(ErrorCallback* callback);
+    void set_throttle_callback(ThrottleCallback* callback);
+    void set_log_callback(LogCallback* callback);
+    void set_stats_callback(StatsCallback* callback);
+    void set_socket_callback(SocketCallback* callback);
+    void set_partitioner_callback(PartitionerCallback* callback);
+    void set_default_topic_configuration(const ConfigurationMock& conf);
+    void set_opaque(void* ptr);
+
+    DeliveryReportCallback* get_delivery_report_callback() const;
+    RebalanceCallback* get_rebalance_callback() const;
+    OffsetCommitCallback* get_offset_commit_callback() const;
+    ErrorCallback* get_error_callback() const;
+    ThrottleCallback* get_throttle_callback() const;
+    LogCallback* get_log_callback() const;
+    StatsCallback* get_stats_callback() const;
+    SocketCallback* get_socket_callback() const;
+    PartitionerCallback* get_partitioner_callback() const;
+    const ConfigurationMock* get_default_topic_configuration() const;
+    void* get_opaque() const;
+    std::unordered_map<std::string, std::string> get_options() const;
+private:
+    enum class Callback {
+        DeliveryReport,
+        Rebalance,
+        OffsetCommit,
+        Error,
+        Throttle,
+        Log,
+        Stats,
+        Socket,
+        Partitioner
+    };
+
+    struct Hasher {
+        size_t operator()(Callback c) const {
+            return static_cast<size_t>(c);
+        }
+    };
+
+    struct Cloner {
+        ConfigurationMock* operator()(const ConfigurationMock* ptr) const {
+            return new ConfigurationMock(*ptr);
+        }
+    };
+
+    using TopicConfigirationPtr = ClonablePtr<ConfigurationMock,
+                                              std::default_delete<ConfigurationMock>,
+                                              Cloner>;
+
+    template <typename Functor>
+    void set_callback(Callback type, Functor* ptr);
+    template <typename Functor>
+    Functor* get_callback(Callback type) const;
+
+    std::unordered_map<std::string, std::string> options_;
+    std::unordered_map<Callback, void*, Hasher> callbacks_;
+    TopicConfigirationPtr default_topic_configuration_;
+    void* opaque_;
+};
+
+} // mocking
+} // cppkafka
+
+#endif // CPPKAFKA_MOCKING_CONFIGURATION_MOCK_H
diff --git a/mocking/include/cppkafka/mocking/handle_wrapper.h b/mocking/include/cppkafka/mocking/handle_wrapper.h
@@ -0,0 +1,32 @@
+#ifndef CPPKAFKA_MOCKING_HANDLE_WRAPPER_H
+#define CPPKAFKA_MOCKING_HANDLE_WRAPPER_H
+
+#include <utility>
+
+namespace cppkafka {
+namespace mocking {
+
+template <typename T>
+class HandleWrapper {
+public:
+    template <typename... Args>
+    HandleWrapper(Args&&... args)
+    : handle_(std::forward<Args>(args)...) {
+
+    }
+
+    T& get_handle() {
+        return handle_;
+    }
+
+    const T& get_handle() const {
+        return handle_;
+    }
+private:
+    T handle_;
+};
+
+} // mocking
+} // cppkafka
+
+#endif // CPPKAFKA_MOCKING_HANDLE_WRAPPER_H
diff --git a/mocking/src/CMakeLists.txt b/mocking/src/CMakeLists.txt
@@ -0,0 +1,13 @@
+set(SOURCES
+    configuration_mock.cpp
+    api.cpp
+)
+
+include_directories(${PROJECT_SOURCE_DIR}/mocking/include/
+                    ${PROJECT_SOURCE_DIR}/include/)
+include_directories(SYSTEM ${Boost_INCLUDE_DIRS} ${RDKAFKA_INCLUDE_DIR})
+
+add_library(cppkafka_mock EXCLUDE_FROM_ALL ${CPPKAFKA_LIBRARY_TYPE} ${SOURCES})
+set_target_properties(cppkafka_mock PROPERTIES VERSION ${CPPKAFKA_VERSION}
+                                               SOVERSION ${CPPKAFKA_VERSION})
+target_link_libraries(cppkafka_mock ${RDKAFKA_LIBRARY})
diff --git a/mocking/src/api.cpp b/mocking/src/api.cpp
diff --git a/mocking/src/configuration_mock.cpp b/mocking/src/configuration_mock.cpp
