CCats/daemon/test/JsonCommanderTest.cpp

#include <gmock/gmock.h>
#include <gtest/gtest.h>

#include "../include/JsonCommander.h"
#include "FileManagerMock.h"

namespace {
/* Version tests */
TEST(testVersion, Positive) {
  FileManagerMock fileManager;

  JsonCommander jsonCommander(fileManager);

  const std::string versionString = "0.2";
  Json::Value version;
  version["version"] = versionString;

  JsonCommander::Response response = jsonCommander.testVersion(version);
  EXPECT_TRUE(response.action == JsonCommander::Action::send);
  EXPECT_TRUE(response.json["accept"].asBool());
  EXPECT_EQ(response.json["version"].asString(), versionString);
}

TEST(testVersion, Negative) {
  FileManagerMock fileManager;

  JsonCommander jsonCommander(fileManager);

  const std::string versionString = "0.1";
  Json::Value version;
  version["version"] = versionString;

  JsonCommander::Response response = jsonCommander.testVersion(version);
  EXPECT_TRUE(response.action == JsonCommander::Action::closeAndSend);
  EXPECT_FALSE(response.json["accept"].asBool());
  EXPECT_FALSE(response.json["version"].asString().compare(versionString) == 0);
}

/* Status tests */
TEST(Status, Ok) {
  FileManagerMock fileManager;

  JsonCommander jsonCommander(fileManager);

  const std::string command = "status";
  Json::Value message;
  message["command"] = command;

  JsonCommander::Response response = jsonCommander.execute(message);

  EXPECT_TRUE(response.action == JsonCommander::Action::send);
  EXPECT_EQ(response.json["command"].asString(), command);
  EXPECT_EQ(response.json["response"].asString(), "ok");
}

TEST(Status, Downloading) {
  FileManagerMock fileManager;

  JsonCommander jsonCommander(fileManager);

  const std::string command = "status";
  Json::Value message;
  message["command"] = command;

  ON_CALL(fileManager, isDownloading()).WillByDefault(testing::Return(true));

  JsonCommander::Response response = jsonCommander.execute(message);

  EXPECT_TRUE(response.action == JsonCommander::Action::send);
  EXPECT_EQ(response.json["command"].asString(), command);
  EXPECT_EQ(response.json["response"].asString(), "download running");
}

TEST(Status, Uploading) {
  FileManagerMock fileManager;

  JsonCommander jsonCommander(fileManager);

  const std::string command = "status";
  Json::Value message;
  message["command"] = command;

  ON_CALL(fileManager, isUploading()).WillByDefault(testing::Return(true));

  JsonCommander::Response response = jsonCommander.execute(message);

  EXPECT_TRUE(response.action == JsonCommander::Action::send);
  EXPECT_EQ(response.json["command"].asString(), command);
  EXPECT_EQ(response.json["response"].asString(), "upload running");
}

TEST(Status, UploadingAndDownloading) {
  FileManagerMock fileManager;

  JsonCommander jsonCommander(fileManager);

  const std::string command = "status";
  Json::Value message;
  message["command"] = command;

  ON_CALL(fileManager, isDownloading()).WillByDefault(testing::Return(true));
  ON_CALL(fileManager, isUploading()).WillByDefault(testing::Return(true));

  JsonCommander::Response response = jsonCommander.execute(message);

  EXPECT_TRUE(response.action == JsonCommander::Action::send);
  EXPECT_EQ(response.json["command"].asString(), command);
  EXPECT_EQ(response.json["response"].asString(),
            "download and upload running");
}

/* Close tests */
TEST(Close, Close) {
  FileManagerMock fileManager;

  JsonCommander jsonCommander(fileManager);

  const std::string command = "close";
  Json::Value message;
  message["command"] = command;

  JsonCommander::Response response = jsonCommander.execute(message);

  EXPECT_TRUE(response.action == JsonCommander::Action::closeAndSend);
  EXPECT_EQ(response.json["command"].asString(), command);
  EXPECT_EQ(response.json["response"].asString(), "bye");
}

/* Put tests */
TEST(Put, Positive) {
  FileManagerMock fileManager;

  JsonCommander jsonCommander(fileManager);

  const std::string command = "put";
  const std::string filename = "cool.txt";
  Json::Value message;
  message["command"] = command;
  message["file"] = filename;
  message["size"] = 1337;
  message["chunks"] = 1;

  ON_CALL(fileManager, openPutFile(testing::_))
      .WillByDefault(testing::Return(true));

  JsonCommander::Response response = jsonCommander.execute(message);

  EXPECT_TRUE(response.action == JsonCommander::Action::send);
  EXPECT_EQ(response.json["command"].asString(), command);
  EXPECT_TRUE(response.json["accept"].asBool());
  EXPECT_EQ(response.json["file"].asString(), filename);
  EXPECT_EQ(response.json["error"].asString(), "");
}

TEST(Put, Negative) {
  FileManagerMock fileManager;

  JsonCommander jsonCommander(fileManager);

  const std::string command = "put";
  const std::string filename = "cool.txt";
  Json::Value message;
  message["command"] = command;
  message["file"] = filename;
  message["size"] = 1337;
  message["chunks"] = 1;

  ON_CALL(fileManager, openPutFile(testing::_))
      .WillByDefault(testing::Return(false));

  JsonCommander::Response response = jsonCommander.execute(message);

  EXPECT_TRUE(response.action == JsonCommander::Action::send);
  EXPECT_EQ(response.json["command"].asString(), command);
  EXPECT_FALSE(response.json["accept"].asBool());
  EXPECT_EQ(response.json["file"].asString(), filename);
  EXPECT_TRUE(response.json["error"].asString().length() > 0);
}

/* Putdata tests */
TEST(Putdata, Positive) {
  FileManagerMock fileManager;

  JsonCommander jsonCommander(fileManager);

  /* start with put */
  std::string command = "put";
  const std::string filename = "cool.txt";
  Json::Value message;
  message["command"] = command;
  message["file"] = filename;
  message["size"] = 1337;
  const int chunks = 3;
  message["chunks"] = chunks;

  ON_CALL(fileManager, openPutFile(testing::_))
      .WillByDefault(testing::Return(true));

  JsonCommander::Response response = jsonCommander.execute(message);

  EXPECT_TRUE(response.action == JsonCommander::Action::send);
  EXPECT_EQ(response.json["command"].asString(), command);
  EXPECT_TRUE(response.json["accept"].asBool());
  EXPECT_EQ(response.json["file"].asString(), filename);
  EXPECT_EQ(response.json["error"].asString(), "");

  /* putdata */
  command = "putdata";

  ON_CALL(fileManager, isUploading()).WillByDefault(testing::Return(true));
  ON_CALL(fileManager, getPutBaseFileName())
      .WillByDefault(testing::Return(filename));

  for (int remaining = chunks - 1; remaining >= 0; remaining--) {
    message = Json::Value();
    message["command"] = command;
    message["file"] = filename;
    message["data"] = "MTMzNw==";
    message["remaining"] = remaining;
    message["cancel"] = false;

    response = jsonCommander.execute(message);

    EXPECT_TRUE(response.action == JsonCommander::Action::send);
    EXPECT_EQ(response.json["command"].asString(), command);
    EXPECT_FALSE(response.json["cancel"].asBool());
    EXPECT_EQ(response.json["received"].asInt(), remaining);
    EXPECT_EQ(response.json["file"].asString(), filename);
    EXPECT_EQ(response.json["error"].asString(), "");
  }
}

TEST(Putdata, Cancel) {
  FileManagerMock fileManager;

  JsonCommander jsonCommander(fileManager);

  /* start with put */
  std::string command = "put";
  const std::string filename = "cool.txt";
  Json::Value message;
  message["command"] = command;
  message["file"] = filename;
  message["size"] = 1337;
  const int chunks = 3;
  message["chunks"] = chunks;

  ON_CALL(fileManager, openPutFile(testing::_))
      .WillByDefault(testing::Return(true));

  JsonCommander::Response response = jsonCommander.execute(message);

  EXPECT_TRUE(response.action == JsonCommander::Action::send);
  EXPECT_EQ(response.json["command"].asString(), command);
  EXPECT_TRUE(response.json["accept"].asBool());
  EXPECT_EQ(response.json["file"].asString(), filename);
  EXPECT_EQ(response.json["error"].asString(), "");

  /* putdata */
  command = "putdata";

  ON_CALL(fileManager, isUploading()).WillByDefault(testing::Return(true));
  ON_CALL(fileManager, getPutBaseFileName())
      .WillByDefault(testing::Return(filename));

  int remaining = chunks - 1;
  message = Json::Value();
  message["command"] = command;
  message["file"] = filename;
  message["data"] = "MTMzNw==";
  message["remaining"] = remaining;
  message["cancel"] = false;

  response = jsonCommander.execute(message);

  EXPECT_TRUE(response.action == JsonCommander::Action::send);
  EXPECT_EQ(response.json["command"].asString(), command);
  EXPECT_FALSE(response.json["cancel"].asBool());
  EXPECT_EQ(response.json["received"].asInt(), remaining);
  EXPECT_EQ(response.json["file"].asString(), filename);
  EXPECT_EQ(response.json["error"].asString(), "");

  // cancel transfer
  message = Json::Value();
  message["command"] = command;
  message["file"] = filename;
  message["data"] = "MTMzNw==";
  message["remaining"] = --remaining;
  message["cancel"] = true;

  response = jsonCommander.execute(message);

  EXPECT_TRUE(response.action == JsonCommander::Action::send);
  EXPECT_EQ(response.json["command"].asString(), command);
  EXPECT_TRUE(response.json["cancel"].asBool());
  EXPECT_EQ(response.json["received"].asInt(), remaining);
  EXPECT_EQ(response.json["file"].asString(), filename);
  EXPECT_EQ(response.json["error"].asString(), "");
}

TEST(Putdata, WrongRemaining) {
  FileManagerMock fileManager;

  JsonCommander jsonCommander(fileManager);

  /* start with put */
  std::string command = "put";
  const std::string filename = "cool.txt";
  Json::Value message;
  message["command"] = command;
  message["file"] = filename;
  message["size"] = 1337;
  const int chunks = 3;
  message["chunks"] = chunks;

  ON_CALL(fileManager, openPutFile(testing::_))
      .WillByDefault(testing::Return(true));

  JsonCommander::Response response = jsonCommander.execute(message);

  EXPECT_TRUE(response.action == JsonCommander::Action::send);
  EXPECT_EQ(response.json["command"].asString(), command);
  EXPECT_TRUE(response.json["accept"].asBool());
  EXPECT_EQ(response.json["file"].asString(), filename);
  EXPECT_EQ(response.json["error"].asString(), "");

  /* putdata */
  command = "putdata";

  ON_CALL(fileManager, isUploading()).WillByDefault(testing::Return(true));
  ON_CALL(fileManager, getPutBaseFileName())
      .WillByDefault(testing::Return(filename));

  int remaining = chunks - 1;
  message = Json::Value();
  message["command"] = command;
  message["file"] = filename;
  message["data"] = "MTMzNw==";
  message["remaining"] = remaining;
  message["cancel"] = false;

  response = jsonCommander.execute(message);

  EXPECT_TRUE(response.action == JsonCommander::Action::send);
  EXPECT_EQ(response.json["command"].asString(), command);
  EXPECT_FALSE(response.json["cancel"].asBool());
  EXPECT_EQ(response.json["received"].asInt(), remaining);
  EXPECT_EQ(response.json["file"].asString(), filename);
  EXPECT_EQ(response.json["error"].asString(), "");
  message = Json::Value();

  // skip remaining=1 and provoke an error
  remaining = 0;
  message = Json::Value();
  message["command"] = command;
  message["file"] = filename;
  message["data"] = "MTMzNw==";
  message["remaining"] = remaining;
  message["cancel"] = false;

  response = jsonCommander.execute(message);

  EXPECT_TRUE(response.action == JsonCommander::Action::send);
  EXPECT_EQ(response.json["command"].asString(), command);
  EXPECT_TRUE(response.json["cancel"].asBool());
  EXPECT_EQ(response.json["received"].asInt(), remaining);
  EXPECT_EQ(response.json["file"].asString(), filename);
  EXPECT_TRUE(response.json["error"].asString().length() > 0);
}

/* Get tests */
TEST(Get, Positive) {
  FileManagerMock fileManager;

  JsonCommander jsonCommander(fileManager);

  const std::string command = "get";
  const std::string filename = "cool.txt";
  Json::Value message;
  message["command"] = command;
  message["file"] = filename;

  EXPECT_CALL(fileManager, openGetFile(testing::_, testing::_))
      .WillOnce(testing::DoAll(testing::SetArgReferee<1, int>(3),
                               testing::Return(true)));

  JsonCommander::Response response = jsonCommander.execute(message);

  EXPECT_TRUE(response.action == JsonCommander::Action::send);
  EXPECT_EQ(response.json["command"].asString(), command);
  EXPECT_TRUE(response.json["accept"].asBool());
  EXPECT_EQ(response.json["file"].asString(), filename);
  EXPECT_TRUE(response.json["chunks"].asInt() > 0);
  EXPECT_EQ(response.json["error"].asString(), "");
}

TEST(Get, Negative) {
  FileManagerMock fileManager;

  JsonCommander jsonCommander(fileManager);

  const std::string command = "get";
  const std::string filename = "cool.txt";
  Json::Value message;
  message["command"] = command;
  message["file"] = filename;

  EXPECT_CALL(fileManager, openGetFile(testing::_, testing::_))
      .WillOnce(testing::Return(false));

  JsonCommander::Response response = jsonCommander.execute(message);

  EXPECT_TRUE(response.action == JsonCommander::Action::send);
  EXPECT_EQ(response.json["command"].asString(), command);
  EXPECT_FALSE(response.json["accept"].asBool());
  EXPECT_EQ(response.json["file"].asString(), filename);
  EXPECT_EQ(response.json["chunks"].asInt(), -1);
  EXPECT_TRUE(response.json["error"].asString().length() > 0);
}

/* Getdata tests */
TEST(Getdata, Positive) {
  FileManagerMock fileManager;

  JsonCommander jsonCommander(fileManager);

  std::string command = "get";
  const std::string filename = "cool.txt";
  Json::Value message;
  message["command"] = command;
  message["file"] = filename;

  const int chunks = 3;
  EXPECT_CALL(fileManager, openGetFile(testing::_, testing::_))
      .WillOnce(testing::DoAll(testing::SetArgReferee<1, int>(chunks),
                               testing::Return(true)));

  JsonCommander::Response response = jsonCommander.execute(message);

  EXPECT_TRUE(response.action == JsonCommander::Action::send);
  EXPECT_EQ(response.json["command"].asString(), command);
  EXPECT_TRUE(response.json["accept"].asBool());
  EXPECT_EQ(response.json["file"].asString(), filename);
  EXPECT_EQ(response.json["chunks"].asInt(), chunks);
  EXPECT_EQ(response.json["error"].asString(), "");

  /* getdata */
  command = "getdata";

  ON_CALL(fileManager, isDownloading()).WillByDefault(testing::Return(true));
  ON_CALL(fileManager, getGetBaseFileName())
      .WillByDefault(testing::Return(filename));

  std::vector<char> data;
  data.push_back('1');
  data.push_back('3');
  data.push_back('3');
  data.push_back('7');

  ON_CALL(fileManager, readGet()).WillByDefault(testing::Return(data));

  for (int remaining = chunks - 1; remaining >= 0; remaining--) {
    message = Json::Value();
    message["command"] = command;
    message["file"] = filename;
    message["chunk"] = remaining;
    message["cancel"] = false;

    response = jsonCommander.execute(message);

    EXPECT_TRUE(response.action == JsonCommander::Action::send);
    EXPECT_EQ(response.json["command"].asString(), command);
    EXPECT_FALSE(response.json["cancel"].asBool());
    EXPECT_EQ(response.json["remaining"].asInt(), remaining);
    EXPECT_EQ(response.json["file"].asString(), filename);
    EXPECT_EQ(response.json["data"].asString(), "MTMzNw==");
    EXPECT_EQ(response.json["error"].asString(), "");
  }
}

TEST(Getdata, Cancle) {
  FileManagerMock fileManager;

  JsonCommander jsonCommander(fileManager);

  std::string command = "get";
  const std::string filename = "cool.txt";
  Json::Value message;
  message["command"] = command;
  message["file"] = filename;

  const int chunks = 3;
  EXPECT_CALL(fileManager, openGetFile(testing::_, testing::_))
      .WillOnce(testing::DoAll(testing::SetArgReferee<1, int>(chunks),
                               testing::Return(true)));

  JsonCommander::Response response = jsonCommander.execute(message);

  EXPECT_TRUE(response.action == JsonCommander::Action::send);
  EXPECT_EQ(response.json["command"].asString(), command);
  EXPECT_TRUE(response.json["accept"].asBool());
  EXPECT_EQ(response.json["file"].asString(), filename);
  EXPECT_EQ(response.json["chunks"].asInt(), chunks);
  EXPECT_EQ(response.json["error"].asString(), "");

  /* getdata */
  command = "getdata";

  ON_CALL(fileManager, isDownloading()).WillByDefault(testing::Return(true));
  ON_CALL(fileManager, getGetBaseFileName())
      .WillByDefault(testing::Return(filename));

  std::vector<char> data;
  data.push_back('1');
  data.push_back('3');
  data.push_back('3');
  data.push_back('7');

  ON_CALL(fileManager, readGet()).WillByDefault(testing::Return(data));

  int remaining = chunks - 1;
  message = Json::Value();
  message["command"] = command;
  message["file"] = filename;
  message["chunk"] = remaining;
  message["cancel"] = false;

  response = jsonCommander.execute(message);

  EXPECT_TRUE(response.action == JsonCommander::Action::send);
  EXPECT_EQ(response.json["command"].asString(), command);
  EXPECT_FALSE(response.json["cancel"].asBool());
  EXPECT_EQ(response.json["remaining"].asInt(), remaining);
  EXPECT_EQ(response.json["file"].asString(), filename);
  EXPECT_EQ(response.json["data"].asString(), "MTMzNw==");
  EXPECT_EQ(response.json["error"].asString(), "");

  // set cancel to true
  message = Json::Value();
  message["command"] = command;
  message["file"] = filename;
  message["chunk"] = --remaining;
  message["cancel"] = true;

  response = jsonCommander.execute(message);

  EXPECT_TRUE(response.action == JsonCommander::Action::send);
  EXPECT_EQ(response.json["command"].asString(), command);
  EXPECT_TRUE(response.json["cancel"].asBool());
  EXPECT_EQ(response.json["remaining"].asInt(), remaining);
  EXPECT_EQ(response.json["file"].asString(), filename);
  EXPECT_EQ(response.json["data"].asString(), "");
  EXPECT_EQ(response.json["error"].asString(), "");
}

TEST(Getdata, WrongChunk) {
  FileManagerMock fileManager;

  JsonCommander jsonCommander(fileManager);

  std::string command = "get";
  const std::string filename = "cool.txt";
  Json::Value message;
  message["command"] = command;
  message["file"] = filename;

  const int chunks = 3;
  EXPECT_CALL(fileManager, openGetFile(testing::_, testing::_))
      .WillOnce(testing::DoAll(testing::SetArgReferee<1, int>(chunks),
                               testing::Return(true)));

  JsonCommander::Response response = jsonCommander.execute(message);

  EXPECT_TRUE(response.action == JsonCommander::Action::send);
  EXPECT_EQ(response.json["command"].asString(), command);
  EXPECT_TRUE(response.json["accept"].asBool());
  EXPECT_EQ(response.json["file"].asString(), filename);
  EXPECT_EQ(response.json["chunks"].asInt(), chunks);
  EXPECT_EQ(response.json["error"].asString(), "");

  /* getdata */
  command = "getdata";

  ON_CALL(fileManager, isDownloading()).WillByDefault(testing::Return(true));
  ON_CALL(fileManager, getGetBaseFileName())
      .WillByDefault(testing::Return(filename));

  std::vector<char> data;
  data.push_back('1');
  data.push_back('3');
  data.push_back('3');
  data.push_back('7');

  ON_CALL(fileManager, readGet()).WillByDefault(testing::Return(data));

  int remaining = chunks - 1;
  message = Json::Value();
  message["command"] = command;
  message["file"] = filename;
  message["chunk"] = remaining;
  message["cancel"] = false;

  response = jsonCommander.execute(message);

  EXPECT_TRUE(response.action == JsonCommander::Action::send);
  EXPECT_EQ(response.json["command"].asString(), command);
  EXPECT_FALSE(response.json["cancel"].asBool());
  EXPECT_EQ(response.json["remaining"].asInt(), remaining);
  EXPECT_EQ(response.json["file"].asString(), filename);
  EXPECT_EQ(response.json["data"].asString(), "MTMzNw==");
  EXPECT_EQ(response.json["error"].asString(), "");

  // skip chunk=0
  remaining = 0;
  message = Json::Value();
  message["command"] = command;
  message["file"] = filename;
  message["chunk"] = remaining;
  message["cancel"] = false;

  response = jsonCommander.execute(message);

  EXPECT_TRUE(response.action == JsonCommander::Action::send);
  EXPECT_EQ(response.json["command"].asString(), command);
  EXPECT_TRUE(response.json["cancel"].asBool());
  EXPECT_EQ(response.json["remaining"].asInt(), remaining);
  EXPECT_EQ(response.json["file"].asString(), filename);
  EXPECT_EQ(response.json["data"].asString(), "");
  EXPECT_TRUE(response.json["error"].asString().length() > 0);
}

/* List tests */
TEST(List, Positive) {
  FileManagerMock fileManager;

  JsonCommander jsonCommander(fileManager);

  const std::string command = "list";
  Json::Value message;
  message["command"] = command;

  EXPECT_CALL(fileManager, openList()).WillOnce(testing::Return(1));
  EXPECT_CALL(fileManager, getListSize()).WillOnce(testing::Return(5));

  JsonCommander::Response response = jsonCommander.execute(message);

  EXPECT_TRUE(response.action == JsonCommander::Action::send);
  EXPECT_EQ(response.json["command"].asString(), command);
  EXPECT_TRUE(response.json["accept"].asBool());
  EXPECT_EQ(response.json["chunks"].asInt(), 1);
  EXPECT_EQ(response.json["items"].asInt(), 5);
  EXPECT_EQ(response.json["error"].asString(), "");
}

TEST(List, Negative) {
  FileManagerMock fileManager;

  JsonCommander jsonCommander(fileManager);

  const std::string command = "list";
  Json::Value message;
  message["command"] = command;

  EXPECT_CALL(fileManager, openList()).WillOnce(testing::Return(-1));

  JsonCommander::Response response = jsonCommander.execute(message);

  EXPECT_TRUE(response.action == JsonCommander::Action::send);
  EXPECT_EQ(response.json["command"].asString(), command);
  EXPECT_FALSE(response.json["accept"].asBool());
  EXPECT_EQ(response.json["chunks"].asInt(), -1);
  EXPECT_EQ(response.json["items"].asInt(), -1);
  EXPECT_TRUE(response.json["error"].asString().compare("") != 0);
}

TEST(List, EmptyList) {
  FileManagerMock fileManager;

  JsonCommander jsonCommander(fileManager);

  const std::string command = "list";
  Json::Value message;
  message["command"] = command;

  EXPECT_CALL(fileManager, openList()).WillOnce(testing::Return(0));
  EXPECT_CALL(fileManager, getListSize()).WillOnce(testing::Return(0));

  JsonCommander::Response response = jsonCommander.execute(message);

  EXPECT_TRUE(response.action == JsonCommander::Action::send);
  EXPECT_EQ(response.json["command"].asString(), command);
  EXPECT_TRUE(response.json["accept"].asBool());
  EXPECT_EQ(response.json["chunks"].asInt(), 0);
  EXPECT_EQ(response.json["items"].asInt(), 0);
  EXPECT_EQ(response.json["error"].asString(), "");
}

/* Listdata tests */

void fillExampleFileList(std::vector<std::string> (&chunk)[3]) {
  chunk[0].push_back("file01.txt");
  chunk[0].push_back("bumdibumps");
  chunk[0].push_back("1");
  chunk[0].push_back("Ich habe Hunger.txt");
  chunk[0].push_back("answerIs42");
  chunk[0].push_back("123456789456115811");
  chunk[0].push_back("kek");
  chunk[1].push_back("1337");
  chunk[1].push_back("cats.png");
  chunk[1].push_back("more_cats.png");
  chunk[1].push_back("ugly dog.tiff");
  chunk[1].push_back("hello.txt");
  chunk[1].push_back("bye.exe");
  chunk[1].push_back("poster.pdf");
  chunk[2].push_back("headbang.gif");
  chunk[2].push_back("feelsbad.jpg");
  chunk[2].push_back("hack.s");
  chunk[2].push_back("SodiumChloride");
  chunk[2].push_back(
      "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrst"
      "uvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMN"
      "OPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
}

TEST(Listdata, Positive) {
  FileManagerMock fileManager;

  JsonCommander jsonCommander(fileManager);

  const std::string command = "listdata";

  const int chunks = 3;
  std::vector<std::string> chunk[chunks];
  fillExampleFileList(chunk);

  int remaining = chunks - 1;

  for (int k = 0; k < chunks; k++) {
    Json::Value message;
    message["command"] = command;
    message["chunk"] = remaining;
    message["cancel"] = false;

    EXPECT_CALL(fileManager, getRemainingListChunks())
        .WillOnce(testing::Return(remaining + 1));
    EXPECT_CALL(fileManager, getNextChunkFromList())
        .WillOnce(testing::Return(chunk[k]));

    JsonCommander::Response response = jsonCommander.execute(message);

    EXPECT_TRUE(response.action == JsonCommander::Action::send);
    EXPECT_EQ(response.json["command"].asString(), command);
    EXPECT_FALSE(response.json["cancel"].asBool());
    EXPECT_EQ(response.json["remaining"].asInt(), remaining--);
    EXPECT_TRUE(response.json["names"].isArray());
    Json::Value array = response.json["names"];
    EXPECT_EQ(array.size(), chunk[k].size());
    for (int i = 0; i < 3; i++) {
      EXPECT_EQ(array[i].asString(), chunk[k][i]);
    }
    EXPECT_EQ(response.json["error"].asString(), "");
  }
}

TEST(Listdata, Cancel) {
  FileManagerMock fileManager;

  JsonCommander jsonCommander(fileManager);

  const std::string command = "listdata";

  const int chunks = 3;
  std::vector<std::string> chunk[chunks];
  fillExampleFileList(chunk);

  int remaining = chunks - 1;

  Json::Value message;
  message["command"] = command;
  message["chunk"] = remaining;
  message["cancel"] = false;

  EXPECT_CALL(fileManager, getRemainingListChunks())
      .WillOnce(testing::Return(remaining + 1));
  EXPECT_CALL(fileManager, getNextChunkFromList())
      .WillOnce(testing::Return(chunk[0]));

  JsonCommander::Response response = jsonCommander.execute(message);

  EXPECT_TRUE(response.action == JsonCommander::Action::send);
  EXPECT_EQ(response.json["command"].asString(), command);
  EXPECT_FALSE(response.json["cancel"].asBool());
  EXPECT_EQ(response.json["remaining"].asInt(), remaining--);
  EXPECT_TRUE(response.json["names"].isArray());
  Json::Value array = response.json["names"];
  EXPECT_EQ(array.size(), chunk[0].size());
  for (int i = 0; i < 3; i++) {
    EXPECT_EQ(array[i].asString(), chunk[0][i]);
  }
  EXPECT_EQ(response.json["error"].asString(), "");

  message = Json::Value();
  message["command"] = command;
  message["chunk"] = remaining;
  message["cancel"] = true;

  EXPECT_CALL(fileManager, getRemainingListChunks())
      .WillOnce(testing::Return(remaining + 1));

  response = jsonCommander.execute(message);
  EXPECT_TRUE(response.action == JsonCommander::Action::send);
  EXPECT_EQ(response.json["command"].asString(), command);
  EXPECT_TRUE(response.json["cancel"].asBool());
  EXPECT_EQ(response.json["remaining"].asInt(), remaining--);
  EXPECT_TRUE(response.json["names"].isArray());
  EXPECT_EQ(response.json["error"].asString(), "");
}

TEST(Listdata, WrongChunkNumber) {
  FileManagerMock fileManager;

  JsonCommander jsonCommander(fileManager);

  const std::string command = "listdata";

  const int chunks = 3;
  int remaining = chunks - 1;

  Json::Value message;
  message["command"] = command;
  message["chunk"] = remaining;
  message["cancel"] = false;

  // return smaller remaining
  EXPECT_CALL(fileManager, getRemainingListChunks())
      .WillOnce(testing::Return(remaining));

  JsonCommander::Response response = jsonCommander.execute(message);

  EXPECT_TRUE(response.action == JsonCommander::Action::closeAndSend);
  EXPECT_EQ(response.json["command"].asString(), command);
  EXPECT_TRUE(response.json["cancel"].asBool());
  EXPECT_EQ(response.json["remaining"].asInt(), -1);
  EXPECT_TRUE(response.json["names"].isArray());
  EXPECT_TRUE(response.json["error"].asString().compare("") != 0);
}

TEST(Listdata, NoChunksToBeSend) {
  FileManagerMock fileManager;

  JsonCommander jsonCommander(fileManager);

  const std::string command = "listdata";

  const int chunks = 0;

  Json::Value message;
  message["command"] = command;
  message["chunk"] = 1;
  message["cancel"] = false;

  // return smaller remaining
  EXPECT_CALL(fileManager, getRemainingListChunks())
      .WillOnce(testing::Return(chunks));

  JsonCommander::Response response = jsonCommander.execute(message);

  EXPECT_TRUE(response.action == JsonCommander::Action::send);
  EXPECT_EQ(response.json["command"].asString(), command);
  EXPECT_TRUE(response.json["cancel"].asBool());
  EXPECT_EQ(response.json["remaining"].asInt(), -1);
  EXPECT_TRUE(response.json["names"].isArray());
  EXPECT_TRUE(response.json["error"].asString().compare("") != 0);
}

TEST(Listdata, InvalidRequest) {
  FileManagerMock fileManager;

  JsonCommander jsonCommander(fileManager);

  const std::string command = "listdata";

  const int chunks = 3;

  Json::Value message;
  message["command"] = command;
  message["chunk"] = 1;

  // return smaller remaining
  EXPECT_CALL(fileManager, getRemainingListChunks())
      .WillOnce(testing::Return(chunks));

  JsonCommander::Response response = jsonCommander.execute(message);

  EXPECT_TRUE(response.action == JsonCommander::Action::closeAndSend);
  EXPECT_EQ(response.json["command"].asString(), command);
  EXPECT_TRUE(response.json["cancel"].asBool());
  EXPECT_EQ(response.json["remaining"].asInt(), -1);
  EXPECT_TRUE(response.json["names"].isArray());
  EXPECT_TRUE(response.json["error"].asString().compare("") != 0);
}

} // namespace