Allow mock testing using the async_resolver and async_connection.

glynos · glynos · commit d9b40ce066fd · 2013-12-18T19:07:07.000+01:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -136,8 +136,8 @@ if(CPP-NETLIB_BUILD_TESTS)
 
   set(GMOCK_ROOT ${CPP-NETLIB_SOURCE_DIR}/deps/gmock)
   set(GMOCK_FOUND ON)
-  set(GMOCK_INCLUDE_DIRS ${GTEST_INCLUDE_DIRS} {${GMOCK_DIR}/include)
-  set(GMOCK_LIBRARY {$GTEST_LIBRARIES} gmock)
+  set(GMOCK_INCLUDE_DIRS ${GTEST_INCLUDE_DIRS} ${GMOCK_ROOT}/include)
+  set(GMOCK_LIBRARY ${GTEST_LIBRARIES} gmock)
   set(GMOCK_MAIN_LIBRARY gmock_main)
   set(GMOCK_BOTH_LIBRARIES ${GMOCK_LIBRARY} ${GMOCK_MAIN_LIBRARY})
 
diff --git a/http/src/http/v2/client/client.cpp b/http/src/http/v2/client/client.cpp
@@ -24,7 +24,7 @@ namespace network {
 
       struct request_helper {
 
-        std::unique_ptr<client_connection::async_connection> connection_;
+        std::shared_ptr<client_connection::async_connection> connection_;
 
         client::request request_;
         client::request_options options_;
@@ -36,23 +36,26 @@ namespace network {
 
         // TODO configure deadline timer for timeouts
 
-        request_helper(boost::asio::io_service &io_service,
+        request_helper(std::shared_ptr<client_connection::async_connection> connection,
                        client::request request,
                        client::request_options options)
-          // TODO factory based on HTTP or HTTPS
-          : connection_(new client_connection::normal_connection(io_service))
+          : connection_(connection)
           , request_(request)
           , options_(options) { }
 
       };
 
       struct client::impl {
 
-	explicit impl(client_options options);
+        explicit impl(client_options options);
+
+        impl(std::unique_ptr<client_connection::async_resolver> mock_resolver,
+             std::unique_ptr<client_connection::async_connection> mock_connection,
+             client_options options);
 
-	~impl() noexcept;
+        ~impl() noexcept;
 
-	std::future<response> do_request(std::shared_ptr<request_helper> helper);
+        std::future<response> execute(std::shared_ptr<request_helper> helper);
 
         void connect(const boost::system::error_code &ec,
                      tcp::resolver::iterator endpoint_iterator,
@@ -80,30 +83,42 @@ namespace network {
                                 std::shared_ptr<request_helper> helper,
                                 std::shared_ptr<response> res);
 
-	client_options options_;
-	boost::asio::io_service io_service_;
-	std::unique_ptr<boost::asio::io_service::work> sentinel_;
+        client_options options_;
+        boost::asio::io_service io_service_;
+        std::unique_ptr<boost::asio::io_service::work> sentinel_;
         boost::asio::io_service::strand strand_;
         std::unique_ptr<client_connection::async_resolver> resolver_;
-	std::thread lifetime_thread_;
+        std::shared_ptr<client_connection::async_connection> mock_connection_;
+        std::thread lifetime_thread_;
 
       };
 
       client::impl::impl(client_options options)
-	: options_(options)
-	, sentinel_(new boost::asio::io_service::work(io_service_))
+        : options_(options)
+        , sentinel_(new boost::asio::io_service::work(io_service_))
         , strand_(io_service_)
-	, resolver_(new client_connection::tcp_resolver(io_service_, options_.cache_resolved()))
-	, lifetime_thread_([=] () { io_service_.run(); }) {
+        , resolver_(new client_connection::tcp_resolver(io_service_, options_.cache_resolved()))
+        , lifetime_thread_([=] () { io_service_.run(); }) {
+
+      }
+
+      client::impl::impl(std::unique_ptr<client_connection::async_resolver> mock_resolver,
+                         std::unique_ptr<client_connection::async_connection> mock_connection,
+                         client_options options)
+        : options_(options)
+        , sentinel_(new boost::asio::io_service::work(io_service_))
+        , strand_(io_service_)
+        , resolver_(std::move(mock_resolver))
+        , lifetime_thread_([=] () { io_service_.run(); }) {
 
       }
 
       client::impl::~impl() noexcept {
-	sentinel_.reset();
-	lifetime_thread_.join();
+        sentinel_.reset();
+        lifetime_thread_.join();
       }
 
-      std::future<client::response> client::impl::do_request(std::shared_ptr<request_helper> helper) {
+      std::future<client::response> client::impl::execute(std::shared_ptr<request_helper> helper) {
         std::future<client::response> res = helper->response_promise_.get_future();
 
         // TODO see linearize.hpp
@@ -131,14 +146,14 @@ namespace network {
           uri::string_type(std::begin(*auth.host()), std::end(*auth.host())) : uri::string_type();
         auto port = auth.port<std::uint16_t>()? *auth.port<std::uint16_t>() : 80;
 
-	resolver_->async_resolve(host, port,
+        resolver_->async_resolve(host, port,
                                  strand_.wrap(
                                    [=](const boost::system::error_code &ec,
                                        tcp::resolver::iterator endpoint_iterator) {
                                      connect(ec, endpoint_iterator, helper);
                                    }));
 
-	return res;
+        return res;
       }
 
       void client::impl::connect(const boost::system::error_code &ec,
@@ -322,42 +337,61 @@ namespace network {
       }
 
       client::client(client_options options)
-	: pimpl_(new impl(options)) {
+        : pimpl_(new impl(options)) {
+
+      }
+
+      client::client(std::unique_ptr<client_connection::async_resolver> mock_resolver,
+                     std::unique_ptr<client_connection::async_connection> mock_connection,
+                     client_options options)
+        : pimpl_(new impl(std::move(mock_resolver), std::move(mock_connection), options)) {
 
       }
 
       client::~client() noexcept {
-	delete pimpl_;
+        delete pimpl_;
+      }
+
+      std::future<client::response> client::execute(request req, request_options options) {
+        std::shared_ptr<client_connection::async_connection> connection;
+        if (pimpl_->mock_connection_) {
+          connection = pimpl_->mock_connection_;
+        }
+        else {
+          // TODO factory based on HTTP or HTTPS
+          connection = std::make_shared<client_connection::normal_connection>(pimpl_->io_service_);
+        }
+        return pimpl_->execute(std::make_shared<request_helper>(connection, req, options));
       }
 
       std::future<client::response> client::get(request req, request_options options) {
-	req.method(method::get);
-	return pimpl_->do_request(std::make_shared<request_helper>(pimpl_->io_service_, req, options));
+        req.method(method::get);
+        return execute(req, options);
       }
 
       std::future<client::response> client::post(request req, request_options options) {
-	req.method(method::post);
-	return pimpl_->do_request(std::make_shared<request_helper>(pimpl_->io_service_, req, options));
+        req.method(method::post);
+        return execute(req, options);
       }
 
       std::future<client::response> client::put(request req, request_options options) {
-	req.method(method::put);
-	return pimpl_->do_request(std::make_shared<request_helper>(pimpl_->io_service_, req, options));
+        req.method(method::put);
+        return execute(req, options);
       }
 
       std::future<client::response> client::delete_(request req, request_options options) {
-	req.method(method::delete_);
-	return pimpl_->do_request(std::make_shared<request_helper>(pimpl_->io_service_, req, options));
+        req.method(method::delete_);
+        return execute(req, options);
       }
 
       std::future<client::response> client::head(request req, request_options options) {
-	req.method(method::head);
-	return pimpl_->do_request(std::make_shared<request_helper>(pimpl_->io_service_, req, options));
+        req.method(method::head);
+        return execute(req, options);
       }
 
       std::future<client::response> client::options(request req, request_options options) {
-	req.method(method::options);
-	return pimpl_->do_request(std::make_shared<request_helper>(pimpl_->io_service_, req, options));
+        req.method(method::options);
+        return execute(req, options);
       }
     } // namespace v2
   } // namespace http
diff --git a/http/src/network/http/v2/client/client.hpp b/http/src/network/http/v2/client/client.hpp
@@ -29,6 +29,11 @@
 namespace network {
   namespace http {
     namespace v2 {
+      namespace client_connection {
+        class async_resolver;
+        class async_connection;
+      } // namespace client_connection
+
       /**
        * \ingroup http_client
        * \class client_options network/http/v2/client/client.hpp network/http/v2/client.hpp
@@ -240,8 +245,8 @@ namespace network {
        */
       class client {
 
-        client(client const &) = delete;
-        client(client &&) = delete;
+        client(const client&) = delete;
+        client& operator=(const client&) = delete;
 
       public:
 
@@ -261,48 +266,59 @@ namespace network {
          */
         explicit client(client_options options = client_options());
 
+        client(std::unique_ptr<client_connection::async_resolver> mock_resolver,
+               std::unique_ptr<client_connection::async_connection> mock_connection,
+               client_options options = client_options());
+
         /**
          * \brief Destructor.
          */
         ~client() noexcept;
 
         /**
-         * \brief Makes an HTTP GET request.
+         * \brief Executes an HTTP request.
+         * \param req The request object.
+         * \param options The request options.
+         */
+        std::future<response> execute(request req, request_options options = request_options());
+
+        /**
+         * \brief Executes an HTTP GET request.
          * \param req The request object.
          * \param options The request options.
          */
         std::future<response> get(request req, request_options options = request_options());
 
         /**
-         * \brief Makes an HTTP POST request.
+         * \brief Executes an HTTP POST request.
          * \param req The request object.
          * \param options The request options.
          */
         std::future<response> post(request req, request_options options = request_options());
 
         /**
-         * \brief Makes an HTTP PUT request.
+         * \brief Executes an HTTP PUT request.
          * \param req The request object.
          * \param options The request options.
          */
         std::future<response> put(request req, request_options options = request_options());
 
         /**
-         * \brief Makes an HTTP DELETE request.
+         * \brief Executes an HTTP DELETE request.
          * \param req The request object.
          * \param options The request options.
          */
         std::future<response> delete_(request req, request_options options = request_options());
 
         /**
-         * \brief Makes an HTTP HEAD request.
+         * \brief Executes an HTTP HEAD request.
          * \param req The request object.
          * \param options The request options.
          */
         std::future<response> head(request req, request_options options = request_options());
 
         /**
-         * \brief Makes an HTTP OPTIONS request.
+         * \brief Executes an HTTP OPTIONS request.
          * \param req The request object.
          * \param options The request options.
          */
diff --git a/http/test/CMakeLists.txt b/http/test/CMakeLists.txt
@@ -12,6 +12,7 @@ include_directories(
   ${CPP-NETLIB_SOURCE_DIR}/logging/src
   ${CPP-NETLIB_SOURCE_DIR}/http/src
   ${GTEST_INCLUDE_DIRS}
+  ${GMOCK_INCLUDE_DIRS}
   ${IGLOO_INCLUDE_DIR}
   ${CPP-NETLIB_SOURCE_DIR})
 
diff --git a/http/test/v2/client/units/CMakeLists.txt b/http/test/v2/client/units/CMakeLists.txt
@@ -5,6 +5,7 @@
 
 set(CPP-NETLIB_CLIENT_TESTS
   client_options_test
+  client_resolution_test
   request_options_test
   byte_source_test
   request_test
@@ -23,7 +24,7 @@ foreach(test ${CPP-NETLIB_CLIENT_TESTS})
     network-uri
     network-http-v2-client
     ${Boost_LIBRARIES}
-    ${GTEST_BOTH_LIBRARIES}
+    ${GMOCK_BOTH_LIBRARIES}
     ${ICU_LIBRARIES} ${ICU_I18N_LIBRARIES}
     ${CMAKE_THREAD_LIBS_INIT}
     )
diff --git a/http/test/v2/client/units/client_resolution_test.cpp b/http/test/v2/client/units/client_resolution_test.cpp
