handle command/event and give out response

include/test/Config.h

@@ -5,6 +5,7 @@
 #include <memory>
 
 #include <boost/filesystem.hpp>
+#include <boost/range/iterator_range.hpp>
 #include <nlohmann/json.hpp>
 
 #include "test/Service.h"
@@ -14,6 +15,9 @@ namespace xs { namespace test
 {
     class Config final
     {
+    private:
+        using service_range_type = std::deque<Service>;
+
     public:
         Config() = delete;
         explicit Config(const boost::filesystem::path& file);
@@ -24,10 +28,14 @@ namespace xs { namespace test
         Config& operator=(const Config&) = delete;
         Config& operator=(Config&&) = delete;
 
+        boost::iterator_range<
+            service_range_type::const_iterator
+        > getServices() const noexcept;
+
     private:
         static bool verify(const nlohmann::json& object) noexcept;
 
-    public:
+    private:
         std::deque<Service> services_;
     };
 } }

include/test/Service.h

@@ -28,6 +28,9 @@ namespace xs { namespace test
         explicit Service(const nlohmann::json& object);
         static bool verify(const nlohmann::json& object) noexcept;
 
+        bool isCommand() const noexcept;
+        bool isEvent() const noexcept;
+
     private:
         Service(Type type, std::string name, nlohmann::json response) noexcept;
 

include/test/Tester.h

@@ -2,6 +2,7 @@
 #define XS_TEST_TESTER_H_INCLUDED
 
 #include <memory>
+#include <unordered_map>
 
 #include <boost/filesystem.hpp>
 
@@ -25,11 +26,19 @@ namespace xs { namespace test
 
         explicit Tester(const boost::filesystem::path& file);
 
+        void wait() noexcept;
+
     private: 
+        std::string onCommand(const std::string& name, const std::string& params) noexcept;
+        void onEvent(const std::string& name, const std::string& params) noexcept;
+
+        void registerServices() noexcept;
 
     public:
         Config config_;
         ExchangeServer server_;
+        std::unordered_map<std::string, const Service*> acceptCommands_;
+        std::unordered_map<std::string, const Service*> acceptEvents_;
     };
 } }
 

res/example/config.json

+{
+    "mockData": [
+        {
+            "command": "aaa",
+            "response": "123"
+        },
+        {
+            "event" : "bbb",
+            "response" : { "value": 456 }
+        }
+    ]
+}

src/test/Config.cc

@@ -4,6 +4,7 @@
 #include <nlohmann/json.hpp>
 
 #include <fstream>
+#include <iterator>
 #include <memory>
 #include <sstream>
 #include <stdexcept>
@@ -42,6 +43,15 @@ Config::Config(const boost::filesystem::path& file)
     }
 }
 
+boost::iterator_range<
+    Config::service_range_type::const_iterator
+> Config::getServices() const noexcept
+{
+    return boost::make_iterator_range(
+        std::begin(services_), std::end(services_)
+    );
+}
+
 bool Config::verify(const nlohmann::json& object) noexcept
 {
     if (!(object.count("mockData") && object["mockData"].is_array())) {

src/test/Service.cc

@@ -43,4 +43,14 @@ namespace xs { namespace test
     , name_(std::move(name))
     , response_(std::move(response))
     { }
+
+    bool Service::isCommand() const noexcept
+    {
+        return type_ == Type::COMMAND;
+    }
+
+    bool Service::isEvent() const noexcept
+    {
+        return type_ == Type::EVENT;
+    }
 } }

src/test/Tester.cc

+#include "test/Service.h"
 #include "test/Tester.h"
 
+#include <boost/range/adaptors.hpp>
+
+#include <chrono>
+#include <functional>
+#include <thread>
 
 
 namespace xs { namespace test {
@@ -9,6 +15,60 @@ Tester::Tester(const boost::filesystem::path& file)
 , server_(
     "xs-test", { }, { }, 0, nullptr
 )
-{ }
+{
+    registerServices();
+}
+
+void Tester::registerServices() noexcept
+{
+    acceptCommands_.clear();
+    acceptEvents_.clear();
+
+    using namespace std::placeholders;
+    for (const auto& service : config_.getServices()) {
+        if (service.isCommand()) {
+            server_.onCmd(
+                service.name_,
+                std::bind(&Tester::onCommand, this, _1, _2)
+            );
+            acceptCommands_[service.name_] = &service;
+        } else {
+            server_.onEvent(
+                service.name_,
+                std::bind(&Tester::onEvent, this, _1, _2)
+            );
+            acceptEvents_[service.name_] = &service;
+        }
+    }
+} 
+
+std::string Tester::onCommand(const std::string& name, const std::string& params) noexcept
+{
+    const auto found = acceptCommands_.find(name);
+    const auto* service = std::get<1>(*found);
+    const auto& response = service->response_;
+
+    /// TODO: keep track the status
+
+    return response.is_string() ? response.get<std::string>()
+                                : response.dump();
+}
+
+void Tester::onEvent(const std::string& name, const std::string& params) noexcept
+{
+    const auto found = acceptEvents_.find(name);
+    const auto* service = std::get<1>(*found);
+    const auto& response = service->response_;
+
+    /// TODO: keep track the status
+}
+
+void Tester::wait() noexcept
+{
+    using namespace std::chrono_literals;
+    while (true) {
+        std::this_thread::sleep_for(1s);
+    }
+}
 
 } }

src/xs-test.cc

@@ -21,14 +21,6 @@ int main(int argc, char* argv[]) {
         return EXIT_FAILURE;
     }
 
-    using namespace xs::test;
-    const Tester tester{configFile};
-    for (const auto& service : tester.config_.services_) {
-        if (service.type_ == Service::Type::COMMAND) {
-            std::cout << "command: " << service.name_;
-        } else {
-            std::cout << "event: " << service.name_;
-        }
-        std::cout << ", response: " << service.response_ << std::endl;
-    }
+    xs::test::Tester tester{configFile};
+    tester.wait();
 }