lay/toREST/tests/stubs/SessionContext.cpp

#include <Catch/catch.hpp>
#include <ServerContext.hpp>
#include <SessionContext.hpp>
#include <vector>

void TestSession::theTorrentExists() {
  torrents_.emplace_back();
  auto &torrent = torrents_.back();
  libtorrent::sha1_hash sha1_hash;
  std::stringstream ss;
  ss << torrent_id;
  ss >> sha1_hash;
  torrent.hash_ = sha1_hash;
  torrent.valid = true;
  REQUIRE(get_torrents().size() == 1);
}

void TestSessionSettings::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 TestSessionSettings::set_bool(int type, int value) {
  set_int(type, value);
}
int TestSessionSettings::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_;
  }
  return 0;
};
bool TestSessionSettings::get_bool(int type) { return get_int(type); }
std::string TestSessionSettings::get_str(int type) {
  if (type == listen_interfaces) {
    return listen_interfaces_;
  }
  return "";
}
void TestSessionSettings::set_str(int type, std::string value) {
  if (type == listen_interfaces) {
    listen_interfaces_ = value;
  }
}
bool TestSession::is_valid() {
  return valid;
}
TestSessionSettings TestSession::get_settings() {
  return settings_;
}
bool TestSession::is_paused() const {
  return paused;
}
void TestSession::pause() {
  paused = true;
}
void TestSession::resume() {
  paused = false;
}
int TestSession::listen_port() {
  return std::stoi(settings_.listen_interfaces_.substr(8, settings_.listen_interfaces_.size() - 8));
}
bool TestSession::is_dht_running() const {
  return settings_.enable_dht_;
}
std::vector<TestTorrent> &TestSession::get_torrents() {
  return torrents_;
}

TestTorrent &TestSession::find_torrent(const libtorrent::sha1_hash &hash) {
  auto itr = std::find_if(torrents_.begin(), torrents_.end(), [&](TestTorrent torrent) {
    return torrent.info_hash() == hash;
  });
  if (itr != torrents_.end()) {
    return *itr;
  }
  return invalid_;
}

void TestSession::remove_torrent(const TestTorrent &torrent, int options = -1) {
  if (options > -1) {
  torrents_.erase(std::find_if(torrents_.begin(), torrents_.end(), [&](TestTorrent a) {
      return a.info_hash() == torrent.info_hash();
    }));
  }
}

void TestSession::apply_settings(TestSessionSettings settings) {
  settings_ = settings;
};

void TestSession::async_add_torrent(const libtorrent::add_torrent_params &settings) {
  torrents_.emplace_back(settings);
};

void TestSession::post_torrent_updates(int flags) {
  post_torrent_updates_calls_++;
}