lay/toREST/tests/session_test.cpp

#include <Catch/fakeit.hpp>
#include <fakeserver.hpp>
#include <session.hpp>

using namespace std;

class TestTorrent {};
class TestRequest {
public:
  std::stringstream content;
};
class TestResponse : public std::stringstream {
public:
  std::string buffer;
  auto string() {
    buffer = str();
    return buffer;
  }
  auto message() {
    if (buffer.empty())
      string();
    auto msg = buffer.substr(13, buffer.find('\r') - 13);
    return msg;
  }
  auto code() {
    if (buffer.empty())
      string();
    return buffer.substr(9, 3);
  }
};

class TestSessionSettings {
public:
  int download_rate_limit = 1;
  int upload_rate_limit = 2;
  int listen_interfaces = 3;
  int enable_dht = 4;
  bool enable_dht_ = false;
  int download_rate_limit_ = 0;
  int upload_rate_limit_ = 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;
    }
    if (type == upload_rate_limit) {
      upload_rate_limit_=value;
    }
    if (type == enable_dht) {
      enable_dht_=value;
    }
  }
  void set_bool(int type, int value) {
    set_int(type, value);
  }
  int get_int(int type) const {
    if (type == download_rate_limit) {
      return download_rate_limit_;
    }
    if (type == upload_rate_limit) {
      return upload_rate_limit_;
    }
    if (type == enable_dht) {
      return enable_dht_;
    }
  };
  bool get_bool(int type){ return get_int(type); }
  std::string get_str(int type){
    if (type == listen_interfaces) {
      return listen_interfaces_;
    }
  }
  void set_str(int type, std::string value){
    if (type == listen_interfaces) {
      listen_interfaces_=value;
    }
  }
};

class TestTorrentSession {
public:
  bool valid = false;
  bool paused = false;
  bool dht_running = true;
  bool is_valid() {
    return valid;
  }
  TestSessionSettings get_settings() {
    return TestSessionSettings();
  }
  bool is_paused() {
    return paused;
  }
  void pause() { paused = true; }
  void resume() { paused = false; }
  int listen_port() {
    return 0;
  }
  bool is_dht_running() {
    return dht_running;
  }
  std::vector<TestTorrent> get_torrents() const {
    return std::vector<TestTorrent>();
  }
  void apply_settings(TestSessionSettings){};
};

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 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}";

SCENARIO("We recive a GET request to the /session resource") {
  auto torrent_session = TestTorrentSession();
  auto response = std::make_shared<TestResponse>();
  GIVEN("the session is invalid") {
    auto request = std::make_shared<TestRequest>();
    tr::session::get(torrent_session, response, request);
    THEN("the server should reply with service unavailable") {
      REQUIRE(response->string() == service_unavailable_json);
      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") {
    auto request = std::make_shared<TestRequest>();
    torrent_session.valid = 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") {
      REQUIRE(response->string() == ok_json_paused);
    }
  }
}

SCENARIO("We recive a PATCH request to the /session resource") {
  auto torrent_session = TestTorrentSession();
  auto response = std::make_shared<TestResponse>();
  GIVEN("the session is invalid") {
    auto request = std::make_shared<TestRequest>();
    tr::session::patch(torrent_session, response, request);
    THEN("the server should reply with service unavailable") {
      REQUIRE(response->string() == service_unavailable_json);
    }
  }
  // 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;
  //   torrent_session.paused = true;
  //   tr::session::patch(torrent_session, response, request);
  //   THEN("the server should reply with service unavailable") {
  //     REQUIRE(response->string() == ok_data);
  //   }
  // }
}