Updated tests for client.

glynos · glynos · commit 0c85833f4f10 · 2013-12-01T11:16:02.000+01:00
diff --git a/http/src/http/v2/client/client.cpp b/http/src/http/v2/client/client.cpp
@@ -4,6 +4,7 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 
 #include <future>
+#include <network/uri.hpp>
 #include <network/config.hpp>
 #include <network/http/v2/client/client.hpp>
 #include <network/http/v2/method.hpp>
@@ -23,37 +24,32 @@ namespace network {
       //
       //  }
       //
+      //  void connect(client::string_type host,
+      //               const boost::system::error_code &ec,
+      //               tcp::resolver::iterator endpoint_iterator);
+      //
+      //  void write_request(const boost::system::error_code &ec);
+      //
+      //  void read_response_status(const boost::system::error_code &ec,
+      //                            std::size_t bytes_written);
+      //
+      //  void read_response_headers(const boost::system::error_code &ec,
+      //                             std::size_t bytes_read);
+      //
       //  client::string_type host_;
       //  boost::asio::streambuf request_;
       //  std::promise<response> response_promise_;
       //  boost::asio::streambuf response_;
       //
       //};
 
-      struct resolve_helper {
-
-      };
-
-      struct connect_helper {
-
-      };
-
-      struct request_helper {
-
-      };
-
-      struct response_helper {
-
-      };
-
       struct client::impl {
 
 	explicit impl(client_options options);
 
 	~impl() noexcept;
 
-        void connect(client::string_type host,
-                     const boost::system::error_code &ec,
+        void connect(const boost::system::error_code &ec,
                      tcp::resolver::iterator endpoint_iterator);
 
         void write_request(const boost::system::error_code &ec);
@@ -68,10 +64,10 @@ namespace network {
 
 	client_options options_;
 	boost::asio::io_service io_service_;
-	std::unique_ptr<boost::asio::io_service::work> sentinel_;
-	std::thread lifetime_thread_;
 	async_resolver resolver_;
         normal_connection connection_;
+	std::unique_ptr<boost::asio::io_service::work> sentinel_;
+	std::thread lifetime_thread_;
 
         boost::asio::streambuf request_;
         std::promise<response> response_promise_;
@@ -84,10 +80,10 @@ namespace network {
 
       client::impl::impl(client_options options)
 	: options_(options)
-	, sentinel_(new boost::asio::io_service::work(io_service_))
-	, lifetime_thread_([=] () { io_service_.run(); })
 	, resolver_(io_service_, options.cache_resolved())
-        , connection_(io_service_) {
+        , connection_(io_service_)
+	, sentinel_(new boost::asio::io_service::work(io_service_))
+	, lifetime_thread_([=] () { io_service_.run(); }) {
 
       }
 
@@ -96,30 +92,32 @@ namespace network {
 	lifetime_thread_.join();
       }
 
-      void client::impl::connect(client::string_type host,
-                                 const boost::system::error_code &ec,
+      void client::impl::connect(const boost::system::error_code &ec,
                                  tcp::resolver::iterator endpoint_iterator) {
-        if (ec) {
-          return;
-        }
-
-        if (endpoint_iterator == tcp::resolver::iterator()) {
-          return;
-        }
-
         tcp::endpoint endpoint(*endpoint_iterator);
-        connection_.async_connect(endpoint, host,
-                                  [=] (const boost::system::error_code &ec) {
-                                    write_request(ec);
-                                  });
+        std::cout << "Resolved " << endpoint << std::endl;
+        //connection_.async_connect(endpoint,
+        //                          [=] (const boost::system::error_code &ec) {
+        //                            if (ec) {
+        //                              return;
+        //                            }
+        //
+        //                            std::cout << "Oh." << std::endl;
+        //                            //response_promise_.set_value(v2::response());
+        //                            //write_request(ec);
+        //                          });
       }
 
       void client::impl::write_request(const boost::system::error_code &ec) {
         if (ec) {
           return;
         }
 
-        // request!
+        connection_.async_write(request_,
+                                [=] (const boost::system::error_code &ec,
+                                     std::size_t bytes_written) {
+                                  read_response_status(ec, bytes_written);
+                                });
       }
 
       void client::impl::read_response_status(const boost::system::error_code &ec,
@@ -128,7 +126,13 @@ namespace network {
           return;
         }
 
-        // response
+        connection_.async_read_until(response_,
+                                     "\r\n",
+                                     [=] (const boost::system::error_code &ec,
+                                          std::size_t bytes_read) {
+                                       // fill headers
+                                       read_response_headers(ec, bytes_read);
+                                     });
       }
 
       void client::impl::read_response_headers(const boost::system::error_code &ec,
@@ -137,8 +141,13 @@ namespace network {
           return;
         }
 
-        // response
-      }
+        connection_.async_read_until(response_,
+                                     "\r\n\r\n",
+                                     [=] (const boost::system::error_code &ec,
+                                          std::size_t bytes_read) {
+                                       // um...
+                                     });
+        }
 
       std::future<response> client::impl::do_request(method met,
 						     request req,
@@ -154,13 +163,33 @@ namespace network {
           return response;
         }
 
-        //
-
-	auto endpoints = resolver_.async_resolve(req.host(), req.port(),
-                                                 [=](const boost::system::error_code &ec,
-                                                     tcp::resolver::iterator endpoint_iterator) {
-                                                   this->connect(ec, endpoint_iterator);
-                                                 });
+        uri_builder builder;
+        for (auto header : req.headers()) {
+          // boost::iequals(header.first, "host")
+          if ((header.first == "Host") || (header.first == "host")) {
+            builder
+              .authority(header.second)
+              ;
+            break;
+          }
+        }
+        auto auth = builder.uri();
+        auto host = auth.host()?
+          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,
+                                [=](const boost::system::error_code &ec,
+                                    tcp::resolver::iterator endpoint_iterator) {
+                                  if (ec) {
+                                    if (endpoint_iterator == tcp::resolver::iterator()) {
+                                      return;
+                                    }
+                                    return;
+                                  }
+
+                                  connect(ec, endpoint_iterator);
+                                });
 
 	return response;
       }
diff --git a/http/src/network/http/v2/client/connection/connection.hpp b/http/src/network/http/v2/client/connection/connection.hpp
@@ -55,11 +55,10 @@ namespace network {
         /**
          * \brief Asynchronously creates a connection to an endpoint.
          * \param endpoint The endpoint to which to connect.
-         * \param host The host name.
          * \param callback A callback handler.
          */
-        virtual void async_connect(boost::asio::ip::tcp::endpoint &endpoint,
-                                   const std::string &host, connect_callback callback) = 0;
+        virtual void async_connect(const boost::asio::ip::tcp::endpoint &endpoint,
+                                   connect_callback callback) = 0;
 
         /**
          * \brief Asynchronously writes data across the connection.
diff --git a/http/src/network/http/v2/client/connection/normal_connection.hpp b/http/src/network/http/v2/client/connection/normal_connection.hpp
@@ -32,11 +32,14 @@ namespace network {
 
         }
 
-        virtual void async_connect(boost::asio::ip::tcp::endpoint &endpoint,
-                                   const std::string &host,
+        virtual void async_connect(const boost::asio::ip::tcp::endpoint &endpoint,
                                    connect_callback callback) {
-          socket_.reset(new boost::asio::ip::tcp::socket(io_service_));
+          using boost::asio::ip::tcp;
+          std::cout << "Oh 1." << std::endl;
+          socket_.reset(new tcp::socket{io_service_});
+          std::cout << "Oh 2." << std::endl;
           socket_->async_connect(endpoint, callback);
+          std::cout << "Oh 3." << std::endl;
         }
 
         virtual void async_write(boost::asio::streambuf &command_streambuf,
diff --git a/http/src/network/http/v2/client/connection/ssl_connection.hpp b/http/src/network/http/v2/client/connection/ssl_connection.hpp
@@ -37,8 +37,7 @@ namespace network {
 
 	}
 
-	virtual void async_connect(boost::asio::ip::tcp::endpoint &endpoint,
-                                   const std::string &host,
+	virtual void async_connect(const boost::asio::ip::tcp::endpoint &endpoint,
                                    connect_callback callback) {
 	  context_.reset(new boost::asio::ssl::context(boost::asio::ssl::context::sslv23));
 	  std::vector<std::string> const& certificate_paths =
@@ -54,7 +53,7 @@ namespace network {
 	      context_->add_verify_path(path);
 	    }
 	    context_->set_verify_mode(boost::asio::ssl::context::verify_peer);
-	    context_->set_verify_callback(boost::asio::ssl::rfc2818_verification(host));
+	    //context_->set_verify_callback(boost::asio::ssl::rfc2818_verification(host));
 	  }
 	  else {
 	    context_->set_default_verify_paths();
diff --git a/http/src/network/http/v2/client/response.hpp b/http/src/network/http/v2/client/response.hpp
@@ -102,6 +102,14 @@ namespace network {
 	  swap(headers_, other.headers_);
 	}
 
+        /**
+         * \brief Returns the HTTP version.
+         * \returns The HTTP version.
+         */
+	string_type version() const {
+	  return version_;
+	}
+
         /**
          * \brief Returns the HTTP response status.
          * \returns The status code.
@@ -135,14 +143,6 @@ namespace network {
 	// append_body
 	// get_body
 
-        /**
-         * \brief Returns the HTTP version.
-         * \returns The HTTP version.
-         */
-	string_type version() const {
-	  return version_;
-	}
-
       private:
 
         string_type version_;
diff --git a/http/test/v2/features/client/CMakeLists.txt b/http/test/v2/features/client/CMakeLists.txt
@@ -14,10 +14,11 @@ set(CPP-NETLIB_CLIENT_TESTS
 #endif()
 
 foreach(test ${CPP-NETLIB_CLIENT_TESTS})
-  #if (${CMAKE_CXX_COMPILER_ID} MATCHES GNU)
-  #  set_source_files_properties(${test}.cpp
+  if (${CMAKE_CXX_COMPILER_ID} MATCHES GNU)
+    set_source_files_properties(${test}.cpp
+      PROPERTIES COMPILE_FLAGS "-g")
   #    PROPERTIES COMPILE_FLAGS "-Wall")
-  #endif()
+  endif()
 
   add_executable(cpp-netlib-http-v2-${test} ${test}.cpp)
   target_link_libraries(cpp-netlib-http-v2-${test}
diff --git a/http/test/v2/features/client/client_test.cpp b/http/test/v2/features/client/client_test.cpp
@@ -11,12 +11,32 @@ namespace http = network::http::v2;
 
 Describe(http_client) {
 
+  void SetUp() {
+    client_.reset(new http::client{});
+  }
+
+  void TearDown() {
+
+  }
+
   It(gets_a_response) {
-    http::request request(network::uri("http://127.0.0.1/"));
-    auto response = client_.get(request);
+    http::request request;
+    request
+      .method(http::method::GET)
+      .path("/LICENSE_1_0.txt")
+      .version("1.0")
+      .append_header("Host", "www.boost.org")
+      .append_header("User-Agent", "cpp-netlib client_test")
+      .append_header("Connection", "close");
+    auto future_response = client_->get(request);
+    auto response = future_response.get();
+
+    Assert::That(response.version(), Equals("1.1"));
+    Assert::That(response.status(), Equals(http::status::code::OK));
+    Assert::That(response.status_message(), Equals("OK"));
   }
 
-  http::client client_;
+  std::unique_ptr<http::client> client_;
 
 };
 
diff --git a/http/test/v2/features/client/normal_connection_test.cpp b/http/test/v2/features/client/normal_connection_test.cpp
@@ -17,7 +17,7 @@ namespace http = network::http::v2;
 Describe(normal_http_connection) {
 
   void SetUp() {
-    io_service_.reset(new boost::asio::io_service);
+    io_service_.reset(new boost::asio::io_service{});
     resolver_.reset(new tcp::resolver(*io_service_));
     connection_.reset(new http::normal_connection(*io_service_));
   }
@@ -34,7 +34,7 @@ Describe(normal_http_connection) {
 
     // Make sure that the connection is successful.
     tcp::endpoint endpoint(it->endpoint());
-    connection_->async_connect(endpoint, "www.boost.org",
+    connection_->async_connect(endpoint,
                                [&ec] (const boost::system::error_code &ec_) {
                                  ec = ec_;
                                });
@@ -49,7 +49,7 @@ Describe(normal_http_connection) {
       .path("/LICENSE_1_0.txt")
       .version("1.0")
       .append_header("Host", "www.boost.org")
-      .append_header("User-Agent", "normal_connection_test")
+      .append_header("User-Agent", "cpp-netlib normal_connection_test")
       .append_header("Connection", "close");
 
     // Write the HTTP request to the socket, sending it to the server.

Original file line number	Diff line number	Diff line change
`@@ -37,8 +37,7 @@ namespace network {`
`37`	`37`
`38`	`38`	`}`
`39`	`39`
`40`		`- virtual void async_connect(boost::asio::ip::tcp::endpoint &endpoint,`
`41`		`- const std::string &host,`
	`40`	`+ virtual void async_connect(const boost::asio::ip::tcp::endpoint &endpoint,`
`42`	`41`	`connect_callback callback) {`
`43`	`42`	`context_.reset(new boost::asio::ssl::context(boost::asio::ssl::context::sslv23));`
`44`	`43`	`std::vector<std::string> const& certificate_paths =`
`@@ -54,7 +53,7 @@ namespace network {`
`54`	`53`	`context_->add_verify_path(path);`
`55`	`54`	`}`
`56`	`55`	`context_->set_verify_mode(boost::asio::ssl::context::verify_peer);`
`57`		`- context_->set_verify_callback(boost::asio::ssl::rfc2818_verification(host));`
	`56`	`+ //context_->set_verify_callback(boost::asio::ssl::rfc2818_verification(host));`
`58`	`57`	`}`
`59`	`58`	`else {`
`60`	`59`	`context_->set_default_verify_paths();`