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);
}
} // namespace