oak: Add several unit tests for server

These unfortunately require curl to be available.
When this becomes a problem, we may need to disable them or
find another work-around. Right now, they provide value.

Co-authored-by: Martin Henselmeyer <[email protected]>

Author: cassava

oak/CMakeLists.txt

@@ -22,6 +22,7 @@ add_library(${target}
     # For IDE integration
     ${${target}_PUBLIC_HEADERS}
     src/oak/request_stub.hpp
+    src/oak/curl.hpp
 )
 add_library(${alias} ALIAS ${target})
 set_target_linting(${target})
@@ -52,11 +53,16 @@ if(BUILD_TESTING)
     add_executable(test-oak
         # find src -type f -name "*_test.cpp"
         src/oak/route_muxer_test.cpp
+        src/oak/server_test.cpp
     )
     set_target_properties(test-oak PROPERTIES
         CXX_STANDARD 14
         CXX_STANDARD_REQUIRED ON
     )
+    target_include_directories(test-oak
+      PRIVATE
+        "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>"
+    )
     target_link_libraries(test-oak
         GTest::gtest
         GTest::gtest_main

oak/include/oak/server.hpp

@@ -101,6 +101,9 @@ class Server {
   /**
    * Set the number of threads used for listening to connections.
    * This is the number of requests that can be handled simultaneously.
+   *
+   * NOTE: This doesn't do anything at the moment; a new thread is created
+   * for each connection.
    */
   void set_threads(int n) { listen_threads_ = n; }
 
@@ -114,11 +117,15 @@ class Server {
    */
   void set_address(const std::string& addr) { listen_addr_ = addr; }
 
+  const std::string& address() const { return listen_addr_; }
+
   /**
    * Set the port on which to listen.
    */
   void set_port(int port) { listen_port_ = port; }
 
+  int port() const { return listen_port_; }
+
   /**
    * Returns whether the server has started and is currently listening.
    */

oak/src/oak/curl.hpp

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2023 Robert Bosch GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * \file oak/curl.hpp
+ */
+
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace oak {
+
+struct Curl {
+  std::string method;
+  std::string address;
+  int port;
+  std::string endpoint;
+  std::string data;
+  std::vector<std::string> headers;
+
+ public:
+  static Curl get(const std::string& address, int port, const std::string& endpoint) {
+    Curl c;
+    c.method = "GET";
+    c.address = address;
+    c.port = port;
+    c.endpoint = endpoint;
+    return std::move(c);
+  }
+
+  static Curl post(const std::string& address, int port, const std::string& endpoint,
+                   const std::string& data, const std::string& mime_type) {
+    Curl c;
+    c.method = "POST";
+    c.address = address;
+    c.port = port;
+    c.endpoint = endpoint;
+    c.data = data;
+    c.headers.push_back(std::string("Content-Type: ") + mime_type);
+    return c;
+  }
+
+  std::string to_string() const {
+    std::string buf;
+    buf += "curl -q";
+    buf += " -X " + method;
+    for (const auto& h : headers) {
+      buf += " -H '" + h + "'";
+    }
+    if (data != "") {
+      buf += " -d '" + data + "'";
+    }
+    buf += " http://" + address + ":" + std::to_string(port);
+    if (endpoint != "" && endpoint[0] != '/') {
+      buf += "/";
+    }
+    buf += endpoint;
+    return buf;
+  }
+};
+
+}  // namespace oak

oak/src/oak/server_test.cpp

@@ -0,0 +1,210 @@
+/*
+ * Copyright 2022 Robert Bosch GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * \file oak/server_test.cpp
+ * \see  oak/server_test.hpp
+ */
+
+#include <gtest/gtest.h>  // for TEST, EXPECT_TRUE, ...
+
+#include <iostream>
+#include <map>      // for map<>
+#include <string>   // for string
+#include <utility>  // for tie
+#include <vector>   // for vector<>
+
+#include <array>
+#include <cstdio>
+#include <iostream>
+#include <memory>
+#include <stdexcept>
+#include <string>
+
+#include <cloe/registrar.hpp>
+#include <fable/utility/gtest.hpp>
+
+#include "oak/registrar.hpp"  // for Registrar
+#include "oak/server.hpp"     // for Server
+#include "oak/curl.hpp"       // for Curl
+
+using namespace std;  // NOLINT(build/namespaces)
+
+/**
+ * Executes a (shell) command and return the StdOut
+ */
+std::string exec(const char* cmd) {
+  std::cerr << "Exec: " << cmd << std::endl;
+
+  std::array<char, 128> buffer;
+  std::string result;
+  std::unique_ptr<FILE, decltype(&pclose)> pipe(popen(cmd, "r"), pclose);
+  if (!pipe) {
+    throw std::runtime_error("popen() failed!");
+  }
+  while (fgets(buffer.data(), buffer.size(), pipe.get()) != nullptr) {
+    result += buffer.data();
+  }
+  return result;
+}
+
+std::string exec(const std::string& cmd) { return exec(cmd.c_str()); }
+std::string exec(const oak::Curl& curl) { return exec(curl.to_string()); }
+
+std::string address;
+std::atomic<unsigned short> port;
+
+class Environment : public ::testing::Environment {
+ public:
+  ~Environment() override {}
+  void SetUp() override {
+    address = "127.0.0.1";
+    port = 12340;
+  }
+  void TearDown() override {}
+};
+testing::Environment* const foo_env = testing::AddGlobalTestEnvironment(new Environment);
+
+std::unique_ptr<oak::Server> create_server() {
+  int retry = 0;
+  do {
+    try {
+      auto port_ = port++;
+      std::cout << "Trying " << address << ":" << port_ << std::endl;
+      auto server = std::make_unique<oak::Server>(address, port_);
+      server->listen();
+      // if server is listening, return otherwise retry
+      if (server->is_listening()) {
+        return server;
+      } else {
+        retry++;
+      }
+    } catch (...) {
+      EXPECT_TRUE(false) << "Unexpected exception";
+    }
+  } while (retry < 100);
+
+  return nullptr;
+}
+
+/**
+ * Try to create a server.
+ */
+TEST(oak_server, listen) { auto server = create_server(); }
+
+/**
+ * Test that stopping a not-listening server results in an exception.
+ */
+TEST(oak_server, fail_not_listening) {
+  oak::Server server;
+  EXPECT_THROW(server.stop(), std::runtime_error);
+}
+
+/**
+ * Try to GET a non-existing endpoint.
+ */
+TEST(oak_server, get_nohandler) {
+  auto server = create_server();
+  ASSERT_NE(server, nullptr);
+  auto address_ = server->address();
+  auto port_ = server->port();
+
+  auto result = exec(oak::Curl::get(address_, port_, "test"));
+
+  // Compare result
+  fable::assert_eq(fable::parse_json(result.c_str()), R"({
+    "endpoints": [],
+    "error": "cannot find handler"
+  })");
+}
+
+/**
+ * Try to GET an endpoint.
+ */
+TEST(oak_server, get_handler) {
+  auto server = create_server();
+  ASSERT_NE(server, nullptr);
+  auto address_ = server->address();
+  auto port_ = server->port();
+
+  // Create registrar
+  oak::StaticRegistrar registrar(server.get(), "", nullptr);
+  // Register one pseudo-endpoint
+  std::vector<std::string> data{ "1", "2", "3" };
+  registrar.register_handler("/simulators", cloe::handler::StaticJson(data));
+
+  // Read the pseudo-endpoint
+  auto result = exec(oak::Curl::get(address_, port_, "simulators"));
+
+  // Compare result
+  fable::assert_eq(fable::parse_json(result.c_str()), R"([
+    "1",
+    "2",
+    "3"
+  ])");
+}
+
+/**
+ * @brief Tries to POST to an endpoint which echos the data back
+ */
+TEST(oak_server, post_handler) {
+  auto server = create_server();
+  ASSERT_NE(server, nullptr);
+  auto address_ = server->address();
+  auto port_ = server->port();
+
+  // Create registrar
+  oak::StaticRegistrar registrar(server.get(), "", nullptr);
+  // Register one pseudo-endpoint
+  std::vector<std::string> data{
+      "1",
+      "2",
+      "3",
+  };
+  registrar.register_handler(
+      "/echo", [this](const cloe::Request& request, cloe::Response& response) {
+        switch (request.method()) {
+          case cloe::RequestMethod::POST: {
+            try {
+              const auto json = request.as_json();
+              response.write(json);
+              response.set_status(cloe::StatusCode::OK);
+            } catch (const std::exception& ex) {
+              response.bad_request(cloe::Json{
+                  {"error", ex.what()},
+              });
+            }
+            break;
+          }
+          default: {
+            response.not_allowed(cloe::RequestMethod::POST,
+                                 cloe::Json{
+                                     {"error", "only GET or POST method allowed"},
+                                 });
+          }
+        }
+      });
+
+  // Read the pseudo-endpoint
+  auto result = exec(oak::Curl::post(address_, port_, "echo", R"({"a": "b", "c": "d"})", "application/json"));
+
+  // Compare result
+  fable::assert_eq(fable::parse_json(result.c_str()), R"({
+    "a": "b",
+    "c": "d"
+  })");
+}