facter 2.5.7 → 3.9.6.cfacter.20180606

data/ext/facter/leatherman/curl/tests/mock_curl.hpp

@@ -0,0 +1,85 @@
+#pragma once
+
+#include <string>
+#include <functional>
+#include <curl/curl.h>
+#ifdef _WIN32
+    #include "export.h"
+#else
+    #define MOCK_CURL_EXPORT
+#endif
+
+struct curl_impl
+{
+    enum struct http_method
+    {
+        get,
+        put,
+        post
+    };
+
+    enum struct error_mode
+    {
+        success,
+        easy_perform_error,
+        easy_perform_write_error,
+        http_post_error,
+        http_put_error,
+        set_url_error,
+        set_header_error,
+        set_cookie_error,
+        header_function_error,
+        header_context_error,
+        write_body_function_error,
+        write_body_context_error,
+        read_body_function_error,
+        read_body_context_error,
+        connect_timeout_error,
+        request_timeout_error,
+        ca_bundle_error,
+        ssl_cert_error,
+        ssl_key_error,
+        protocol_error,
+    };
+
+    error_mode test_failure_mode = error_mode::success;
+
+    // Pointer for client::write_header as a callback function in curl_easy_setopt
+    std::function<size_t(char*, size_t, size_t, void*)> write_header;
+    void* header_context; // Where to write the header part of the received data to
+
+    // Pointer for client::write_body as a callback function in curl_easy_setopt
+    std::function<size_t(char*, size_t, size_t, void*)> write_body;
+    void* body_context; // Where to write the body part of the received data to
+
+    // Pointer for client::read_body as a callback function in curl_easy_setopt
+    std::function<size_t(char*, size_t, size_t, void*)> read_function;
+    void* read_data; // Where to read the request body from
+
+    std::string request_url, cookie, cacert, client_cert, client_key;
+    long protocols;
+    long connect_timeout;
+    http_method method = http_method::get;
+
+    curl_slist* header; // List of custom request headers to be passed to the server
+
+    std::string read_buffer; // Buffer to test reading the request body
+    std::string resp_body;   // Response body which should be written to a context using the write_body function callback
+
+    char* errbuf = 0;
+    // Pointer to trigger failure callbacks
+    std::function<void()> trigger_external_failure;
+};
+
+enum error_mode
+{
+    success,
+    easy_init_error,
+    global_init_error
+};
+
+struct MOCK_CURL_EXPORT curl_fail_init
+{
+    curl_fail_init(error_mode mode);
+    ~curl_fail_init();
+};

data/ext/facter/leatherman/curl/tests/request_test.cc

@@ -0,0 +1,87 @@
+#include <catch.hpp>
+#include "mock_curl.hpp"
+#include <leatherman/curl/client.hpp>
+#include <leatherman/curl/request.hpp>
+
+using namespace std;
+
+namespace leatherman { namespace curl {
+
+    struct mock_client : client {
+        curl_handle const& get_handle() { return client::get_handle(); }
+    };
+
+    TEST_CASE("curl::request") {
+        request test_request {"http://valid.com"};
+
+        SECTION("Headers should be addable and retrievable from the request") {
+            test_request.add_header("header_name", "header_value");
+            auto header = test_request.header("header_name");
+            REQUIRE(header);
+            REQUIRE(*(header) == "header_value");
+        }
+
+        SECTION("Headers should be removable from the request") {
+            test_request.add_header("header_name", "header_value");
+            test_request.remove_header("header_name");
+            auto header = test_request.header("header_name");
+            REQUIRE(header == nullptr);
+        }
+
+        SECTION("Headers should be enumerable") {
+            int i = 0;
+            string expected_name, expected_value;
+            test_request.add_header("header_0", "header_value_0");
+            test_request.add_header("header_1", "header_value_1");
+            test_request.add_header("header_2", "header_value_2");
+
+            test_request.each_header([&](string const& name, string const& value) {
+                expected_name  = "header_" + to_string(i);
+                expected_value = "header_value_" + to_string(i);
+                REQUIRE(name == expected_name);
+                REQUIRE(value == expected_value);
+                ++i;
+                return true;
+            });
+        }
+
+        SECTION("A cookie should be retrievable by name") {
+            test_request.add_cookie("cookie_0", "cookie_val_0");
+            test_request.add_cookie("cookie_1", "cookie_val_1");
+            REQUIRE(*(test_request.cookie("cookie_0")) == "cookie_val_0");
+        }
+
+        SECTION("Cookies should be enumerable") {
+            int i = 0;
+            string expected_name, expected_value;
+            test_request.add_cookie("cookie_0", "cookie_value_0");
+            test_request.add_cookie("cookie_1", "cookie_value_1");
+            test_request.add_cookie("cookie_2", "cookie_value_2");
+
+            test_request.each_cookie([&](string const& name, string const& value) {
+                expected_name  = "cookie_" + to_string(i);
+                expected_value = "cookie_value_" + to_string(i);
+                REQUIRE(name == expected_name);
+                REQUIRE(value == expected_value);
+                ++i;
+                return true;
+            });
+        }
+
+        SECTION("Request body should be addable and retrievable") {
+            test_request.body("Hello, I am a request body!", "message");
+            auto body = test_request.body();
+            REQUIRE(body == "Hello, I am a request body!");
+        }
+
+        SECTION("Overall request timeout should be configurable and retrievable") {
+            test_request.timeout(100);
+            REQUIRE(test_request.timeout() == 100);
+        }
+
+        SECTION("Connection timeout should be configurable and retrievable") {
+            test_request.connection_timeout(100);
+            REQUIRE(test_request.connection_timeout() == 100);
+        }
+    }
+}}

data/ext/facter/leatherman/curl/tests/response_test.cc

@@ -0,0 +1,60 @@
+#include <catch.hpp>
+#include "mock_curl.hpp"
+#include <leatherman/curl/client.hpp>
+#include <leatherman/curl/request.hpp>
+
+using namespace std;
+
+namespace leatherman { namespace curl {
+
+    struct mock_client : client {
+        curl_handle const& get_handle() { return client::get_handle(); }
+    };
+
+    TEST_CASE("curl::response") {
+        response test_response;
+
+        SECTION("Headers should be addable and retrievable from the response") {
+            test_response.add_header("header_name", "header_value");
+            auto header = test_response.header("header_name");
+            REQUIRE(header);
+            REQUIRE(*(header) == "header_value");
+        }
+
+        SECTION("Headers should be removable from the response") {
+            test_response.add_header("header_name", "header_value");
+            test_response.remove_header("header_name");
+            auto header = test_response.header("header_name");
+            REQUIRE(header == nullptr);
+        }
+
+        SECTION("Headers should be enumerable") {
+            int i = 0;
+            string expected_name, expected_value;
+            test_response.add_header("header_0", "header_value_0");
+            test_response.add_header("header_1", "header_value_1");
+            test_response.add_header("header_2", "header_value_2");
+
+            test_response.each_header([&](string const& name, string const& value) {
+                expected_name  = "header_" + to_string(i);
+                expected_value = "header_value_" + to_string(i);
+                REQUIRE(name == expected_name);
+                REQUIRE(value == expected_value);
+                ++i;
+                return true;
+            });
+        }
+
+        SECTION("Response body should be addable and retrievable") {
+            test_response.body("Hello, I am a response body!");
+            auto body = test_response.body();
+            REQUIRE(body == "Hello, I am a response body!");
+        }
+
+        SECTION("Status code should be addable and retrievable") {
+            test_response.status_code(200);
+            auto code = test_response.status_code();
+            REQUIRE(code == 200);
+        }
+    }
+}}

data/ext/facter/leatherman/dynamic_library/CMakeLists.txt

@@ -0,0 +1,43 @@
+find_package(Boost 1.54 REQUIRED COMPONENTS regex)
+
+add_leatherman_deps("${Boost_LIBRARIES}")
+add_leatherman_includes("${Boost_INCLUDE_DIRS}")
+
+leatherman_dependency(locale)
+leatherman_dependency(logging)
+leatherman_dependency(util)
+if(WIN32)
+    leatherman_dependency(windows)
+else()
+  if(NOT CMAKE_SYSTEM_NAME MATCHES "FreeBSD|OpenBSD")
+      add_leatherman_deps(dl)
+  endif()
+endif()
+
+if (BUILDING_LEATHERMAN)
+    leatherman_logging_namespace("leatherman.dynamic_library")
+    leatherman_logging_line_numbers()
+endif()
+
+add_leatherman_headers(inc/leatherman)
+if(WIN32)
+    add_leatherman_library(src/windows/dynamic_library.cc src/dynamic_library.cc)
+else()
+    add_leatherman_library(src/posix/dynamic_library.cc src/dynamic_library.cc)
+endif()
+
+add_leatherman_test(tests/dynamic_library_tests.cc)
+
+if (BUILDING_LEATHERMAN)
+
+    #Build dummy dynamic libraries for use in testing
+    add_library(libtest SHARED tests/test-lib/hello.cc)
+    set_target_properties(libtest PROPERTIES PREFIX "" SUFFIX ".so")
+    add_library(libtest1 SHARED tests/test-lib/hello.cc tests/test-lib/goodbye.cc)
+    set_target_properties(libtest1 PROPERTIES PREFIX "" SUFFIX ".so")
+
+    configure_file (
+        "${CMAKE_CURRENT_LIST_DIR}/tests/fixtures.hpp.in"
+        "${CMAKE_CURRENT_LIST_DIR}/tests/fixtures.hpp"
+    )
+endif()

data/ext/facter/leatherman/dynamic_library/inc/leatherman/dynamic_library/dynamic_library.hpp

@@ -0,0 +1,122 @@
+/**
+ * @file
+ * Declares the dynamic library type.
+ */
+#pragma once
+
+#include <string>
+#include <stdexcept>
+#include <initializer_list>
+
+namespace leatherman { namespace dynamic_library {
+
+    /**
+     * Exception thrown for missing imported symbols.
+     */
+    struct missing_import_exception : std::runtime_error
+    {
+        /**
+         * Constructs a missing_import_exception.
+         * @param message The exception message.
+         */
+        explicit missing_import_exception(std::string const& message);
+    };
+
+    /**
+     * Represents a dynamic library.
+     */
+    struct dynamic_library
+    {
+        /**
+         * Constructs a dynamic_library.
+         */
+        dynamic_library();
+
+        /**
+         * Destructs a dynamic_library.
+         */
+        ~dynamic_library();
+
+        /**
+         * Prevents the dynamic_library from being copied.
+         */
+        dynamic_library(dynamic_library const&) = delete;
+        /**
+         * Prevents the dynamic_library from being copied.
+         * @returns Returns this dynamic_library.
+         */
+        dynamic_library& operator=(dynamic_library const&) = delete;
+        /**
+         * Moves the given dynamic_library into this dynamic_library.
+         * @param other The dynamic_library to move into this dynamic_library.
+         */
+        dynamic_library(dynamic_library&& other);
+        /**
+         * Moves the given dynamic_library into this dynamic_library.
+         * @param other The dynamic_library to move into this dynamic_library.
+         * @return Returns this dynamic_library.
+         */
+        dynamic_library& operator=(dynamic_library&& other);
+
+        /**
+         * Finds an already loaded library by file name regex pattern.
+         * @param pattern The regex pattern of the library to find.
+         * @return Returns the already loaded library if found or an unloaded library if not found.
+         */
+        static dynamic_library find_by_pattern(std::string const& pattern);
+        /**
+         * Finds an already loaded library by symbol.
+         * @param symbol The symbol to find.
+         * @return Returns the already loaded library if found or an unloaded library if not found.
+         */
+        static dynamic_library find_by_symbol(std::string const& symbol);
+
+        /**
+         * Loads the given dynamic library.
+         * The current library will be closed before the given library is loaded.
+         * If you rely on the value of first_load(), you should try to call find_by_symbol
+         * before calling this function.
+         * @param name The name of the library to load.
+         * @return Returns true if the library loaded or false if it did not.
+         */
+        bool load(std::string const& name, bool global = false);
+
+        /**
+         * Determines if the library is loaded.
+         * @return Returns true if the library is loaded or false if it is not.
+         */
+        bool loaded() const;
+
+        /**
+         * Determines if the library's load was the first.
+         * @return Returns true if the library was loaded for the first time or false if it was previously loaded.
+         */
+        bool first_load() const;
+
+        /**
+         * Gets the name of the library.
+         * @return Returns the name of the library.
+         */
+        std::string const& name() const;
+
+        /**
+         * Closes the library.
+         */
+        void close();
+
+        /**
+         * Finds a symbol in the library by name.
+         * @param name The name of the symbol to find.
+         * @param throw_if_missing if true, throws an exception if the symbol is missing.  If false, returns nullptr if the symbol is missing.
+         * @param alias The alias of the symbol to load if the given symbol isn't found.
+         * @return Returns the symbol's address or nullptr if not found.
+         */
+        void* find_symbol(std::string const& name, bool throw_if_missing = false, std::string const& alias = {}) const;
+
+     private:
+        void* _handle;
+        std::string _name;
+        bool _first_load;
+    };
+
+}}  // namespace leatherman::load_library

data/ext/facter/leatherman/dynamic_library/src/dynamic_library.cc

@@ -0,0 +1,57 @@
+#include <leatherman/dynamic_library/dynamic_library.hpp>
+
+using namespace std;
+
+namespace leatherman { namespace dynamic_library {
+
+    missing_import_exception::missing_import_exception(string const& message) :
+        runtime_error(message)
+    {
+    }
+
+    dynamic_library::dynamic_library() :
+        _handle(nullptr),
+        _first_load(false)
+    {
+    }
+
+    dynamic_library::~dynamic_library()
+    {
+        close();
+    }
+
+    dynamic_library::dynamic_library(dynamic_library && other) :
+        _handle(nullptr),
+        _first_load(false)
+    {
+        *this = move(other);
+    }
+
+    dynamic_library &dynamic_library::operator=(dynamic_library && other)
+    {
+        close();
+        _handle = other._handle;
+        _name = other._name;
+        _first_load = other._first_load;
+        other._handle = nullptr;
+        other._name.clear();
+        other._first_load = false;
+        return *this;
+    }
+
+    bool dynamic_library::loaded() const
+    {
+        return _handle != nullptr;
+    }
+
+    bool dynamic_library::first_load() const
+    {
+        return _first_load;
+    }
+
+    string const& dynamic_library::name() const
+    {
+        return _name;
+    }
+
+}}  // namespace leatherman::dynamic_library