Enable ecFlow REST API tests using HTTP backend

Re ECFLOW-1957

libs/attribute/src/ecflow/attribute/Variable.cpp

@@ -49,10 +49,12 @@ int Variable::value() const {
 }
 
 bool Variable::operator==(const Variable& rhs) const {
-    if (v_ != rhs.v_)
+    if (v_ != rhs.v_) {
         return false;
-    if (n_ != rhs.n_)
+    }
+    if (n_ != rhs.n_) {
         return false;
+    }
     return true;
 }
 

libs/base/src/ecflow/base/HttpClient.cpp

@@ -22,6 +22,8 @@ HttpClient::HttpClient(Cmd_ptr cmd_ptr, const std::string& host, const std::stri
       port_(port),
       client_(host, ecf::convert_to<int>(port)) {
 
+    client_.set_connection_timeout(std::chrono::seconds{timeout});
+
     if (!cmd_ptr.get()) {
         throw std::runtime_error("Client::Client: No request specified !");
     }
@@ -36,6 +38,7 @@ void HttpClient::run() {
     auto result = client_.Post("/v1/ecflow", outbound, "application/json");
     if (result) {
         auto response = result.value();
+        status_ = httplib::Error::Success;
         ecf::restore_from_string(response.body, inbound_response_);
     }
     else {

libs/base/src/ecflow/base/HttpClient.hpp

@@ -28,7 +28,7 @@
 class HttpClient {
 public:
     /// Constructor starts the asynchronous connect operation.
-    HttpClient(Cmd_ptr cmd_ptr, const std::string& host, const std::string& port, int timout = 0);
+    HttpClient(Cmd_ptr cmd_ptr, const std::string& host, const std::string& port, int timout = 60);
 
     void run();
 

libs/client/src/ecflow/client/ClientInvoker.cpp

@@ -431,8 +431,9 @@ int ClientInvoker::do_invoke_cmd(Cmd_ptr cts_cmd) const {
     #endif
                             io.run();
                         }
-                        if (clientEnv_.debug())
+                        if (clientEnv_.debug()) {
                             cout << TimeStamp::now() << "ClientInvoker: >>> After: io_context::run() <<<" << endl;
+                        }
 
                         /// Let see how the server responded if at all.
                         try {
@@ -451,8 +452,9 @@ int ClientInvoker::do_invoke_cmd(Cmd_ptr cts_cmd) const {
                         HttpClient theClient(cts_cmd, clientEnv_.host(), clientEnv_.port());
                         theClient.run();
 
-                        if (clientEnv_.debug())
+                        if (clientEnv_.debug()) {
                             cout << TimeStamp::now() << "ClientInvoker: >>> After: io_service.run() <<<" << endl;
+                        }
 
                         /// Let see how the server responded if at all.
                         try {
@@ -477,8 +479,9 @@ int ClientInvoker::do_invoke_cmd(Cmd_ptr cts_cmd) const {
 #endif
                             io.run();
                         }
-                        if (clientEnv_.debug())
+                        if (clientEnv_.debug()) {
                             cout << TimeStamp::now() << "ClientInvoker: >>> After: io_context::run() <<<" << endl;
+                        }
 
                         /// Let see how the server responded if at all.
                         try {

libs/rest/CMakeLists.txt

@@ -144,6 +144,34 @@ if (ENABLE_HTTP AND ENABLE_SERVER)
     target_clangformat(s_http
       CONDITION ENABLE_TESTS
     )
+
+    ecbuild_add_test(
+      TARGET
+        s_http_using_http_backend
+      LABELS
+        integration nightly
+      SOURCES
+        ${test_srcs}
+      INCLUDES
+        ../base/test
+      DEFINITIONS
+        ECF_TEST_HTTP_BACKEND
+      LIBS
+        libhttp
+        ecflow_all
+        Boost::boost # Boost header-only libraries must be available (namely unit_test_framework)
+        $<$<BOOL:${OPENSSL_FOUND}>:OpenSSL::SSL>
+        test_support
+      DEPENDS
+        ecflow_server # the server is launched to support tests
+        ecflow_http
+      TEST_DEPENDS
+        u_base
+        s_client
+    )
+    target_clangformat(s_http_using_http_backend
+      CONDITION ENABLE_TESTS
+    )
   else ()
     message(WARNING "SSL not enabled - will not run HTTP server tests")
   endif ()

libs/rest/test/InvokeServer.hpp

@@ -27,7 +27,7 @@
 
 class InvokeServer {
 public:
-    InvokeServer() {
+    InvokeServer(bool use_http_backend = false) : use_http_backend_(use_http_backend) {
         std::string port;
         ecf::environment::get(ecf::environment::ECF_PORT, port);
         /// Remove check pt and backup check pt file, else server will load it & remove log file
@@ -43,13 +43,21 @@ class InvokeServer {
 
         BOOST_TEST_MESSAGE("Using eclow_server from " << theServerInvokePath);
 
-        std::thread t([&] { system(theServerInvokePath.c_str()); });
+        std::string cmd = theServerInvokePath;
+        if (use_http_backend_) {
+            cmd += " --http";
+        }
+
+        std::thread t([&] { system(cmd.c_str()); });
 
         t.detach();
 
         sleep(1);
 
         ClientInvoker theClient("localhost", port);
+        if (use_http_backend_) {
+            theClient.enable_http();
+        }
         if (theClient.wait_for_server_reply()) {
             theClient.restartServer();
             server_started = true;
@@ -66,6 +74,9 @@ class InvokeServer {
         BOOST_TEST_MESSAGE("*****InvokeServer:: Closing server on port " << port);
         {
             ClientInvoker theClient("localhost", port);
+            if (use_http_backend_) {
+                theClient.enable_http();
+            }
             BOOST_REQUIRE_NO_THROW(theClient.terminateServer());
             BOOST_REQUIRE_MESSAGE(theClient.wait_for_server_death(), "Failed to terminate server after 60 seconds\n");
         }
@@ -83,6 +94,7 @@ class InvokeServer {
     }
 
     bool server_started{false};
+    bool use_http_backend_{false};
 };
 
 #endif /* ecflow_http_test_InvokeServer_HPP */

libs/rest/test/TestApiV1.cpp

@@ -75,8 +75,13 @@ void start_api_server() {
     }
 
     std::thread t([] {
+#if defined(ECF_TEST_HTTP_BACKEND)
+        int argc     = 4;
+        char* argv[] = {(char*)"ecflow_http", (char*)"--polling_interval", (char*)"1", (char*)"--http", NULL};
+#else
         int argc     = 3;
         char* argv[] = {(char*)"ecflow_http", (char*)"--polling_interval", (char*)"1", NULL};
+#endif
 
         HttpServer server(argc, argv);
         server.run();
@@ -91,7 +96,12 @@ std::unique_ptr<InvokeServer> start_ecflow_server() {
         return nullptr;
     }
 
-    auto srv = std::make_unique<InvokeServer>();
+    bool use_http_backend = false;
+#if defined(ECF_TEST_HTTP_BACKEND)
+    use_http_backend = true;
+#endif
+
+    auto srv = std::make_unique<InvokeServer>(use_http_backend);
 
     auto port = ecf::environment::get("ECF_PORT");
     BOOST_REQUIRE_MESSAGE(srv->server_started, "Server failed to start on port " << port);

libs/test/CMakeLists.txt

@@ -63,6 +63,25 @@ if (ENABLE_ALL_TESTS)
   )
   target_clangformat(s_test CONDITION ENABLE_TESTS)
 
+  ecbuild_add_test(
+    TARGET
+      s_test_http
+    LABELS
+      integration
+      nightly
+    SOURCES
+      ${test_srcs}
+    DEFINITIONS
+      ECFLOW_TEST_SERVER_HTTP
+    LIBS
+      libharness
+      $<$<BOOL:${OPENSSL_FOUND}>:OpenSSL::SSL>
+      test_support
+    TEST_DEPENDS
+      s_client
+  )
+  target_clangformat(s_test_http CONDITION ENABLE_TESTS)
+
   ecbuild_add_test(
     TARGET
       s_zombies