Little hack to make async connection test pass (it's actually synchronous).

glynos · glynos · commit b80ab158f156 · 2013-09-08T14:08:33.000+02:00
diff --git a/http/src/network/http/v2/client/connection/async_resolver_delegate.hpp b/http/src/network/http/v2/client/connection/async_resolver_delegate.hpp
@@ -52,13 +52,14 @@ namespace network {
 	/**
 	 * \brief Resolves a host asynchronously.
 	 */
-	virtual std::future<resolver_iterator_range>
+	virtual std::future<std::pair<boost::system::error_code,
+				      resolver_iterator_range>>
 	resolve(const std::string &host, std::uint16_t port) {
 	  if (cache_resolved_) {
 	    endpoint_cache::iterator it = endpoint_cache_.find(boost::to_lower_copy(host));
 	    if (it != endpoint_cache_.end()) {
-	      boost::system::error_code ignored;
-	      promise_.set_value(it->second);
+	      boost::system::error_code ec;
+	      promise_.set_value(std::make_pair(ec, it->second));
 	      return promise_.get_future();
 	    }
 	  }
@@ -69,14 +70,15 @@ namespace network {
 		  [&host, this](const boost::system::error_code &ec,
 				resolver_iterator endpoint_iterator) {
 		    if (ec) {
-		      promise_.set_value(std::make_pair(resolver_iterator(), resolver_iterator()));
+		      auto resolvers = std::make_pair(resolver_iterator(), resolver_iterator());
+		      promise_.set_value(std::make_pair(ec, resolvers));
 		    }
 		    else {
 		      auto resolvers = std::make_pair(endpoint_iterator, resolver_iterator());
 		      if (cache_resolved_) {
 			endpoint_cache_.insert(std::make_pair(host, resolvers));
 		      }
-		      promise_.set_value(resolvers);
+		      promise_.set_value(std::make_pair(ec, resolvers));
 		    }
 		  }));
 
@@ -94,7 +96,7 @@ namespace network {
 
 	typedef boost::asio::io_service::strand strand;
 	typedef std::unordered_map<std::string, resolver_iterator_range> endpoint_cache;
-	std::promise<resolver_iterator_range> promise_;
+	std::promise<std::pair<boost::system::error_code, resolver_iterator_range>> promise_;
 
 	resolver resolver_;
 	std::unique_ptr<strand> resolver_strand_;
diff --git a/http/src/network/http/v2/client/connection/connection_delegate.hpp b/http/src/network/http/v2/client/connection/connection_delegate.hpp
@@ -8,6 +8,7 @@
 
 #include <functional>
 #include <string>
+#include <future>
 #include <boost/asio/ip/tcp.hpp>
 #include <boost/asio/streambuf.hpp>
 
@@ -25,9 +26,9 @@ namespace network {
 
 	virtual ~connection_delegate() noexcept { }
 
-	virtual void connect(boost::asio::ip::tcp::endpoint &endpoint,
-			     const std::string &host,
-			     std::function<void (const boost::system::error_code &)> handler) = 0;
+	virtual std::future<boost::system::error_code>
+	connect(boost::asio::ip::tcp::endpoint &endpoint,
+		const std::string &host) = 0;
 
 	virtual void write(boost::asio::streambuf &command_streambuf,
 			   std::function<void (const boost::system::error_code &, size_t)> handler) = 0;
diff --git a/http/src/network/http/v2/client/connection/normal_connection_delegate.hpp b/http/src/network/http/v2/client/connection/normal_connection_delegate.hpp
@@ -29,11 +29,19 @@ namespace network {
 
 	}
 
-	virtual void connect(boost::asio::ip::tcp::endpoint &endpoint,
-			     const std::string &host,
-			     std::function<void (const boost::system::error_code &)> handler) {
+	virtual std::future<boost::system::error_code>
+	connect(boost::asio::ip::tcp::endpoint &endpoint,
+		const std::string &host) {
 	  socket_.reset(new boost::asio::ip::tcp::socket(io_service_));
-	  socket_->async_connect(endpoint, handler);
+//	  socket_->async_connect(endpoint,
+//				 [this](const boost::system::error_code &ec) {
+//				   std::cout << "oh" << std::endl;
+//				   promise_.set_value(ec);
+//				 });
+	  boost::system::error_code ec;
+	  socket_->connect(endpoint, ec);
+	  promise_.set_value(ec);
+	  return promise_.get_future();
 	}
 
 	virtual void write(boost::asio::streambuf &command_streambuf,
@@ -50,6 +58,7 @@ namespace network {
 
 	boost::asio::io_service &io_service_;
 	std::unique_ptr<boost::asio::ip::tcp::socket> socket_;
+	std::promise<boost::system::error_code> promise_;
 
       };
     } // namespace v2
diff --git a/http/src/network/http/v2/client/connection/resolver_delegate.hpp b/http/src/network/http/v2/client/connection/resolver_delegate.hpp
@@ -29,17 +29,15 @@ namespace network {
       public:
 
 	typedef boost::asio::ip::tcp::resolver resolver;
-	typedef boost::asio::ip::tcp::endpoint endpoint;
 	typedef resolver::iterator resolver_iterator;
 	typedef boost::iterator_range<resolver_iterator> resolver_iterator_range;
-	typedef std::function<void (const boost::system::error_code &,
-				    boost::iterator_range<resolver_iterator>)> on_resolved_fn;
 
 	resolver_delegate() = default;
 
 	virtual ~resolver_delegate() noexcept { }
 
-	virtual std::future<resolver_iterator_range>
+	virtual std::future<std::pair<boost::system::error_code,
+				      resolver_iterator_range>>
 	resolve(const std::string &host, std::uint16_t port) = 0;
 
 	virtual void clear_resolved_cache() = 0;
diff --git a/http/test/v2/features/client/async_resolver_test.cpp b/http/test/v2/features/client/async_resolver_test.cpp
@@ -6,6 +6,7 @@
 #include <iostream>
 #include <igloo/igloo_alt.h>
 #include <boost/asio.hpp>
+#include <boost/range/empty.hpp>
 #include "network/http/v2/client/connection/async_resolver_delegate.hpp"
 
 using namespace igloo;
@@ -24,7 +25,9 @@ Describe(async_resolver) {
 
     auto endpoints = resolver_->resolve("127.0.0.1", 80);
     io_service_->run_one();
-    for (auto endpoint : endpoints.get()) {
+    auto result = endpoints.get();
+    Assert::That(result.first, Equals(boost::system::error_code()));
+    for (auto endpoint : result.second) {
       Assert::That(endpoint.endpoint().address().to_string(), Equals("127.0.0.1"));
       Assert::That(endpoint.endpoint().port(), Equals(80));
     }
diff --git a/http/test/v2/features/client/normal_connection_test.cpp b/http/test/v2/features/client/normal_connection_test.cpp
@@ -6,6 +6,7 @@
 #include <memory>
 #include <igloo/igloo_alt.h>
 #include <boost/asio.hpp>
+#include "network/http/v2/client/connection/async_resolver_delegate.hpp"
 #include "network/http/v2/client/connection/normal_connection_delegate.hpp"
 
 using namespace igloo;
@@ -14,19 +15,30 @@ namespace http = network::http::v2;
 
 Describe(normal_http_connection) {
 
-  //void SetUp() {
-  //  io_service_.reset(new boost::asio::io_service);
-  //  connection_.reset(new normal_http_connection(io_service));
-  //
-  //  // resolve endpoints
-  //}
+  void SetUp() {
+    io_service_.reset(new boost::asio::io_service);
+    resolver_.reset(new http::async_resolver_delegate(*io_service_));
+    connection_.reset(new http::normal_connection_delegate(*io_service_));
+
+    // resolve endpoints
+    auto endpoints = resolver_->resolve("127.0.0.1", 80);
+    io_service_->run_one();
+    endpoints_ = endpoints.get();
+  }
 
   It(connects_to_localhost) {
-    //auto ec = connection_.connect(endpoint_, "127.0.0.1");
-    // ec
+    auto it = std::begin(endpoints_.second);
+    tcp::endpoint endpoint(it->endpoint().address(), 80);
+    auto connected = connection_->connect(endpoint, "127.0.0.1");
+    io_service_->run_one();
+    auto connected_ = connected.get();
+    Assert::That(connected_, Equals(boost::system::error_code()));
   }
 
   std::unique_ptr<boost::asio::io_service> io_service_;
+  std::unique_ptr<http::async_resolver_delegate> resolver_;
+  std::pair<boost::system::error_code,
+	    http::async_resolver_delegate::resolver_iterator_range> endpoints_;
   std::unique_ptr<http::connection_delegate> connection_;
 
 };
