adds tests for TLS timers

test/transport/asio/SConscript

@@ -14,15 +14,15 @@ env_cpp11 = env_cpp11.Clone ()
 BOOST_LIBS = boostlibs(['unit_test_framework','system','thread','regex'],env) + [platform_libs] + [tls_libs]
 
 objs = env.Object('base_boost.o', ["base.cpp"], LIBS = BOOST_LIBS)
-#objs += env.Object('timers_boost.o', ["timers.cpp"], LIBS = BOOST_LIBS)
+objs += env.Object('timers_boost.o', ["timers.cpp"], LIBS = BOOST_LIBS)
 prgs = env.Program('test_base_boost', ["base_boost.o"], LIBS = BOOST_LIBS)
-#prgs += env.Program('test_timers_boost', ["timers_boost.o"], LIBS = BOOST_LIBS)
+prgs += env.Program('test_timers_boost', ["timers_boost.o"], LIBS = BOOST_LIBS)
 
 if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
    BOOST_LIBS_CPP11 = boostlibs(['unit_test_framework','system'],env_cpp11) + [platform_libs] + [polyfill_libs] + [tls_libs]
    objs += env_cpp11.Object('base_stl.o', ["base.cpp"], LIBS = BOOST_LIBS_CPP11)
-   #objs += env_cpp11.Object('timers_stl.o', ["timers.cpp"], LIBS = BOOST_LIBS_CPP11)
+   objs += env_cpp11.Object('timers_stl.o', ["timers.cpp"], LIBS = BOOST_LIBS_CPP11)
    prgs += env_cpp11.Program('test_base_stl', ["base_stl.o"], LIBS = BOOST_LIBS_CPP11)
-   #prgs += env_cpp11.Program('test_timers_stl', ["timers_stl.o"], LIBS = BOOST_LIBS_CPP11)
+   prgs += env_cpp11.Program('test_timers_stl', ["timers_stl.o"], LIBS = BOOST_LIBS_CPP11)
 
 Return('prgs')

test/transport/asio/timers.cpp

@@ -44,17 +44,18 @@
 #include <websocketpp/http/response.hpp>
 
 // Loggers
-#include <websocketpp/logger/mock.hpp>
+#include <websocketpp/logger/stub.hpp>
+//#include <websocketpp/logger/basic.hpp>
 
 #include <boost/asio.hpp>
 
 // Accept a connection, read data, and discard until EOF
-void run_dummy_server() {
+void run_dummy_server(int port) {
     using boost::asio::ip::tcp;
     
     try {    
         boost::asio::io_service io_service;
-        tcp::acceptor acceptor(io_service, tcp::endpoint(tcp::v6(), 9005));
+        tcp::acceptor acceptor(io_service, tcp::endpoint(tcp::v6(), port));
         tcp::socket socket(io_service);
     
         acceptor.accept(socket);
@@ -76,10 +77,20 @@ void run_dummy_server() {
     }
 }
 
+// Wait for the specified time period then fail the test
+void run_test_timer(long value) {
+    boost::asio::io_service ios;
+    boost::asio::deadline_timer t(ios,boost::posix_time::milliseconds(value));
+    boost::system::error_code ec;
+    t.wait(ec);
+    BOOST_FAIL( "Test timed out" );
+}
+
 struct config {
     typedef websocketpp::concurrency::none concurrency_type;
-    typedef websocketpp::log::mock alog_type;
-    typedef websocketpp::log::mock elog_type;
+    //typedef websocketpp::log::basic<concurrency_type,websocketpp::log::alevel> alog_type;
+    typedef websocketpp::log::stub alog_type;
+    typedef websocketpp::log::stub elog_type;
     typedef websocketpp::http::parser::request request_type;
     typedef websocketpp::http::parser::response response_type;
     typedef websocketpp::transport::asio::tls_socket::endpoint socket_type;
@@ -92,34 +103,20 @@ struct config {
     static const long timeout_socket_shutdown = 1000;
 };
 
-void run_test_timer() {
-    boost::asio::io_service ios;
-    boost::asio::deadline_timer t(ios,boost::posix_time::milliseconds(1000));
-    t.wait();
-    BOOST_FAIL( "Test timed out" );
-}
-
+// Mock context that does no validation
 typedef websocketpp::lib::shared_ptr<boost::asio::ssl::context> context_ptr;
 context_ptr on_tls_init(websocketpp::connection_hdl hdl) {
-        context_ptr ctx(new boost::asio::ssl::context(boost::asio::ssl::context::tlsv1));
-
-        try {
-            ctx->set_options(boost::asio::ssl::context::default_workarounds |
-                             boost::asio::ssl::context::no_sslv2 |
-                             boost::asio::ssl::context::single_dh_use);
-        } catch (std::exception& e) {
-            std::cout << e.what() << std::endl;
-        }
-        return ctx;
+    return context_ptr(new boost::asio::ssl::context(boost::asio::ssl::context::tlsv1));
 }
 
-struct stub_con: public websocketpp::transport::asio::connection<config> {
+// Mock connection
+struct mock_con: public websocketpp::transport::asio::connection<config> {
     typedef websocketpp::transport::asio::connection<config> base;
     
-    stub_con(bool a, config::alog_type& b, config::elog_type& c) : base(a,b,c) {}
+    mock_con(bool a, config::alog_type& b, config::elog_type& c) : base(a,b,c) {}
     
     void start() {
-        base::init(websocketpp::lib::bind(&stub_con::handle_start,this,
+        base::init(websocketpp::lib::bind(&mock_con::handle_start,this,
             websocketpp::lib::placeholders::_1));
     }
     
@@ -128,41 +125,40 @@ struct stub_con: public websocketpp::transport::asio::connection<config> {
         using websocketpp::transport::asio::socket::error::tls_handshake_timeout;
         
         BOOST_CHECK_EQUAL( ec, make_error_code(tls_handshake_timeout) );
+        
+        base::cancel_socket();
     }
 };
 
 typedef websocketpp::transport::asio::connection<config> con_type;
-typedef websocketpp::lib::shared_ptr<stub_con> connection_ptr;
+typedef websocketpp::lib::shared_ptr<mock_con> connection_ptr;
 
-struct stub_endpoint : public websocketpp::transport::asio::endpoint<config> {
+struct mock_endpoint : public websocketpp::transport::asio::endpoint<config> {
     typedef websocketpp::transport::asio::endpoint<config> base;
     
-    stub_endpoint() {
-        base::init_logging(&mock_logger,&mock_logger);
+    mock_endpoint() {
+        alog.set_channels(websocketpp::log::alevel::all);
+        base::init_logging(&alog,&elog);
         init_asio();
     }
     
-    connection_ptr connect(std::string u) {
-        connection_ptr con(new stub_con(true,mock_logger,mock_logger));
+    void connect(std::string u) {
+        m_con.reset(new mock_con(false,alog,elog));
         websocketpp::uri_ptr uri(new websocketpp::uri(u));
         
-        
-        
-        BOOST_CHECK_EQUAL( base::init(con), websocketpp::lib::error_code() );
+        BOOST_CHECK_EQUAL( base::init(m_con), websocketpp::lib::error_code() );
         
         base::async_connect(
-            con,
+            m_con,
             uri,
             websocketpp::lib::bind(
-                &stub_endpoint::handle_connect,
+                &mock_endpoint::handle_connect,
                 this,
-                con,
+                m_con,
                 websocketpp::lib::placeholders::_1,
                 websocketpp::lib::placeholders::_2
             )
         );
-        
-        return con;
     }
     
     void handle_connect(connection_ptr con, websocketpp::connection_hdl, 
@@ -171,23 +167,20 @@ struct stub_endpoint : public websocketpp::transport::asio::endpoint<config> {
         BOOST_CHECK( !ec );
         con->start();
     }
-
-    void run() {
-        base::run();
-    }
     
-    connection_ptr con;
-    config::alog_type mock_logger;
+    connection_ptr m_con;
+    config::alog_type alog;
+    config::elog_type elog;
 };
 
 BOOST_AUTO_TEST_CASE( tls_handshake_timeout ) {
-    websocketpp::lib::thread dummy_server(&run_dummy_server);
-    //websocketpp::lib::thread timer(&run_test_timer);
-        
-    stub_endpoint endpoint;
+    websocketpp::lib::thread dummy_server(websocketpp::lib::bind(&run_dummy_server,9005));
+    websocketpp::lib::thread timer(websocketpp::lib::bind(&run_test_timer,5000));
+    dummy_server.detach();
+    timer.detach();
+    
+    mock_endpoint endpoint;
     endpoint.set_tls_init_handler(&on_tls_init);
     endpoint.connect("wss://localhost:9005");
     endpoint.run();
-            
-    BOOST_CHECK( true );
 }