Test of session patch resource

toREST/include/session.hpp

@@ -55,7 +55,8 @@ namespace tr{
            if(new_limit!=old_limit)
              settings.set_int(settings.upload_rate_limit,new_limit);
            session.apply_settings(settings);
-           http_response.set_body({{200,"OK"}});
+           auto response_code = http::code(http::accepted);
+           http_response.set_body({{"code",response_code.first},{"status", response_code.second}});
          } else {
            auto response_code = http::code(http::bad_request);
            http_response.set_body({{"code",response_code.first},{"status", response_code.second}});

toREST/tests/session_test.cpp

@@ -35,19 +35,19 @@ public:
   int upload_rate_limit = 2;
   int listen_interfaces = 3;
   int enable_dht = 4;
-  bool enable_dht_ = false;
+  bool enable_dht_ = true;
   int download_rate_limit_ = 0;
   int upload_rate_limit_ = 0;
-  std::string listen_interfaces_="0.0.0.0:0";
+  std::string listen_interfaces_ = "0.0.0.0:0";
   void set_int(int type, int value) {
     if (type == download_rate_limit) {
-      download_rate_limit_=value;
+      download_rate_limit_ = value;
     }
     if (type == upload_rate_limit) {
-      upload_rate_limit_=value;
+      upload_rate_limit_ = value;
     }
     if (type == enable_dht) {
-      enable_dht_=value;
+      enable_dht_ = value;
     }
   }
   void set_bool(int type, int value) {
@@ -63,16 +63,17 @@ public:
     if (type == enable_dht) {
       return enable_dht_;
     }
+    return 0;
   };
-  bool get_bool(int type){ return get_int(type); }
+  bool get_bool(int type) { return get_int(type); }
-  std::string get_str(int type){
+  std::string get_str(int type) {
     if (type == listen_interfaces) {
       return listen_interfaces_;
     }
   }
-  void set_str(int type, std::string value){
+  void set_str(int type, std::string value) {
     if (type == listen_interfaces) {
-      listen_interfaces_=value;
+      listen_interfaces_ = value;
     }
   }
 };
@@ -81,12 +82,12 @@ class TestTorrentSession {
 public:
   bool valid = false;
   bool paused = false;
-  bool dht_running = true;
+  TestSessionSettings settings_;
   bool is_valid() {
     return valid;
   }
   TestSessionSettings get_settings() {
-    return TestSessionSettings();
+    return settings_;
   }
   bool is_paused() {
     return paused;
@@ -94,73 +95,105 @@ public:
   void pause() { paused = true; }
   void resume() { paused = false; }
   int listen_port() {
-    return 0;
+    return std::stoi(settings_.listen_interfaces_.substr(8, settings_.listen_interfaces_.size() - 8));
   }
   bool is_dht_running() {
-    return dht_running;
+    return settings_.enable_dht_;
   }
   std::vector<TestTorrent> get_torrents() const {
     return std::vector<TestTorrent>();
   }
-  void apply_settings(TestSessionSettings){};
+  void apply_settings(TestSessionSettings settings) {
+    settings_ = settings;
+  };
 };
 
-const std::string service_unavailable_json = "HTTP/1.1 503 Service Unavailable\r\nContent-Type: application/json\r\nContent-Length: 43\r\n\r\n{\"code\":503,\"status\":\"Service Unavailable\"}";
+const std::string bad_request_json = "HTTP/1.1 400 Bad Request\r\nContent-Type: application/json\r\nContent-Length: 35\r\n\r\n{\"code\":400,\"status\":\"Bad Request\"}";
 const std::string ok_data = "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: 85\r\n\r\n{\"dht_enabled\":true,\"down_limit\":0,\"paused\":false,\"port\":0,\"torrents\":0,\"up_limit\":0}";
-const std::string ok_json_paused = "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: 84\r\n\r\n{\"dht_enabled\":true,\"down_limit\":0,\"paused\":true,\"port\":0,\"torrents\":0,\"up_limit\":0}";
+const std::string ok_data_paused = "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: 84\r\n\r\n{\"dht_enabled\":true,\"down_limit\":0,\"paused\":true,\"port\":0,\"torrents\":0,\"up_limit\":0}";
+const std::string accepted = "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: 32\r\n\r\n{\"code\":202,\"status\":\"Accepted\"}";
+
+const std::string service_unavailable_json = "HTTP/1.1 503 Service Unavailable\r\nContent-Type: application/json\r\nContent-Length: 43\r\n\r\n{\"code\":503,\"status\":\"Service Unavailable\"}";
+const auto reply_is_service_unavailable = [](std::shared_ptr<TestResponse> response) {
+  REQUIRE(response->string() == service_unavailable_json);
+  REQUIRE(response->code() == "503");
+  REQUIRE(response->message() == "Service Unavailable");
+};
 
-SCENARIO("We recive a GET request to the /session resource") {
+const auto reply_is_200_ok = [](std::shared_ptr<TestResponse> response) {
+  REQUIRE(response->code() == "200");
+  REQUIRE(response->message() == "OK");
+};
+
+SCENARIO("We are running a GET /session resource") {
   auto torrent_session = TestTorrentSession();
   auto response = std::make_shared<TestResponse>();
-  GIVEN("the session is invalid") {
   auto request = std::make_shared<TestRequest>();
+  GIVEN("the server is not working properly") {
+    AND_WHEN("we recive a request") {
       tr::session::get(torrent_session, response, request);
       THEN("the server should reply with service unavailable") {
-      REQUIRE(response->string() == service_unavailable_json);
+        reply_is_service_unavailable(response);
-      REQUIRE(response->code() == "503");
-      REQUIRE(response->message() == "Service Unavailable");
       }
     }
-  GIVEN("the session is valid") {
-    auto request = std::make_shared<TestRequest>();
-    torrent_session.valid = true;
-    tr::session::get(torrent_session, response, request);
-    THEN("the server should reply with status 200 OK") {
-      REQUIRE(response->string() == ok_data);
-      REQUIRE(response->code() == "200");
-      REQUIRE(response->message() == "OK");
-    }
   }
-  GIVEN("the session is paused") {
+  GIVEN("the server is working properly") {
-    auto request = std::make_shared<TestRequest>();
     torrent_session.valid = true;
+    AND_WHEN("the session is paused the paused field is set to true") {
       torrent_session.paused = true;
-    torrent_session.dht_running = true;
       tr::session::get(torrent_session, response, request);
-    THEN("the server should reply with service unavailable") {
+      THEN("the server should reply with resource data") {
-      REQUIRE(response->string() == ok_json_paused);
+        REQUIRE(response->string() == ok_data_paused);
+        reply_is_200_ok(response);
+      }
     }
   }
 }
 
-SCENARIO("We recive a PATCH request to the /session resource") {
+SCENARIO("We recive a PATCH request on the /session resource") {
   auto torrent_session = TestTorrentSession();
   auto response = std::make_shared<TestResponse>();
-  GIVEN("the session is invalid") {
   auto request = std::make_shared<TestRequest>();
+  GIVEN("the server is not working properly") {
     tr::session::patch(torrent_session, response, request);
     THEN("the server should reply with service unavailable") {
-      REQUIRE(response->string() == service_unavailable_json);
+      reply_is_service_unavailable(response);
+    }
+  }
+  GIVEN("the server is working properly") {
+    torrent_session.valid = true;
+    GIVEN("the server recives invalid request") {
+      request->content << "Not valid json";
+      tr::session::patch(torrent_session, response, request);
+      THEN("the server should respond with bad request") {
+        REQUIRE(response->string() == bad_request_json);
+        REQUIRE(response->code() == "400");
+        REQUIRE(response->message() == "Bad Request");
+      }
+    }
+    GIVEN("the server recives a valid request") {
+      const nlohmann::json obj({
+          {"dht_enabled", false},
+          {"paused", true},
+          {"port", 1},
+          {"down_limit", 100},
+          {"up_limit", 100},
+      });
+      request->content << obj;
+      REQUIRE_FALSE(torrent_session.paused);
+      REQUIRE(torrent_session.settings_.enable_dht_);
+      REQUIRE(torrent_session.listen_port() == 0);
+      REQUIRE(torrent_session.settings_.download_rate_limit_ == 0);
+      REQUIRE(torrent_session.settings_.upload_rate_limit_ == 0);
+      tr::session::patch(torrent_session, response, request);
+      REQUIRE(response->string() == accepted);
+      REQUIRE(torrent_session.paused);
+      REQUIRE_FALSE(torrent_session.settings_.enable_dht_);
+      REQUIRE(torrent_session.listen_port() == 1);
+      REQUIRE(torrent_session.settings_.download_rate_limit_ == 100);
+      REQUIRE(torrent_session.settings_.upload_rate_limit_ == 100);
     }
   }
-  // GIVEN("the session is valid") {
-  //   auto request = std::make_shared<TestRequest>();
-  //   torrent_session.valid = true;
-  //   tr::session::patch(torrent_session, response, request);
-  //   THEN("the server should reply with session data") {
-  //     REQUIRE(response->string() == ok_data);
-  //   }
-  // }
   // GIVEN("the session is paused") {
   //   auto request = std::make_shared<TestRequest>();
   //   torrent_session.valid = true;