Adding more jsonCommander tests

And set the autoformat to also format the test folders

autoformat.sh

@@ -1,2 +1,2 @@
 #!/bin/bash
-clang-format -i {daemon,cli,gui}/src/*.cpp {daemon,cli,gui}/include/*.h
+clang-format -i {daemon,cli,gui}/src/*.cpp {daemon,cli,gui}/include/*.h {daemon,cli,gui}/test/*.cpp

daemon/test/JsonCommanderTest.cpp

@@ -1,110 +1,623 @@
-#include <gtest/gtest.h>
 #include <gmock/gmock.h>
+#include <gtest/gtest.h>
 
 #include "../include/JsonCommander.h"
 #include "FileManagerMock.h"
 
 namespace {
-  /* Version tests */
-  TEST(testVersion, Positive) {
-    FileManagerMock fileManager;
+/* Version tests */
+TEST(testVersion, Positive) {
+  FileManagerMock fileManager;
 
-    JsonCommander jsonCommander(fileManager);
+  JsonCommander jsonCommander(fileManager);
 
-    const std::string versionString = "0.2";
-    Json::Value version;
-    version["version"] = versionString;
+  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);
-  }
+  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;
+TEST(testVersion, Negative) {
+  FileManagerMock fileManager;
 
-    JsonCommander jsonCommander(fileManager);
+  JsonCommander jsonCommander(fileManager);
 
-    const std::string versionString = "0.1";
-    Json::Value version;
-    version["version"] = versionString;
+  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);
-  }
+  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;
+
+  ON_CALL(fileManager, openPutFile(testing::_))
+      .WillByDefault(testing::Return(true));
 
-  /* Status tests */
-  TEST(Status, Ok) {
-    FileManagerMock fileManager;
+  JsonCommander::Response response = jsonCommander.execute(message);
 
-    JsonCommander jsonCommander(fileManager);
+  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;
+
+  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 std::string command = "status";
-    Json::Value message;
+  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 = 2; remaining >= 0; remaining--) {
+    message = Json::Value();
     message["command"] = command;
+    message["file"] = filename;
+    message["data"] = "MTMzNw==";
+    message["remaining"] = remaining;
+    message["cancel"] = false;
 
-    JsonCommander::Response response = jsonCommander.execute(message);
+    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");
+    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(Status, Downloading) {
-    FileManagerMock fileManager;
+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;
+
+  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 = 2;
+  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(), "");
+}
 
-    JsonCommander jsonCommander(fileManager);
+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;
+
+  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 = 2;
+  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);
+}
 
-    const std::string command = "status";
-    Json::Value message;
-    message["command"] = command;
+/* Get tests */
+TEST(Get, Positive) {
+  FileManagerMock fileManager;
 
-    ON_CALL(fileManager, isDownloading()).WillByDefault(testing::Return(true));
+  JsonCommander jsonCommander(fileManager);
 
-    JsonCommander::Response response = jsonCommander.execute(message);
+  const std::string command = "get";
+  const std::string filename = "cool.txt";
+  Json::Value message;
+  message["command"] = command;
+  message["file"] = filename;
 
-    EXPECT_TRUE(response.action == JsonCommander::Action::send);
-    EXPECT_EQ(response.json["command"].asString(), command);
-    EXPECT_EQ(response.json["response"].asString(), "download running");
-  }
+  EXPECT_CALL(fileManager, openGetFile(testing::_, testing::_))
+      .WillOnce(testing::DoAll(testing::SetArgReferee<1, int>(3),
+                               testing::Return(true)));
 
-  TEST(Status, Uploading) {
-    FileManagerMock fileManager;
+  JsonCommander::Response response = jsonCommander.execute(message);
 
-    JsonCommander jsonCommander(fileManager);
+  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(), "");
+}
 
-    const std::string command = "status";
-    Json::Value message;
-    message["command"] = command;
+TEST(Get, Negative) {
+  FileManagerMock fileManager;
 
-    ON_CALL(fileManager, isUploading()).WillByDefault(testing::Return(true));
+  JsonCommander jsonCommander(fileManager);
 
-    JsonCommander::Response response = jsonCommander.execute(message);
+  const std::string command = "get";
+  const std::string filename = "cool.txt";
+  Json::Value message;
+  message["command"] = command;
+  message["file"] = filename;
 
-    EXPECT_TRUE(response.action == JsonCommander::Action::send);
-    EXPECT_EQ(response.json["command"].asString(), command);
-    EXPECT_EQ(response.json["response"].asString(), "upload running");
-  }
+  EXPECT_CALL(fileManager, openGetFile(testing::_, testing::_))
+      .WillOnce(testing::Return(false));
 
-  TEST(Status, UploadingAndDownloading) {
-    FileManagerMock fileManager;
+  JsonCommander::Response response = jsonCommander.execute(message);
 
-    JsonCommander jsonCommander(fileManager);
+  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);
+}
 
-    const std::string command = "status";
-    Json::Value message;
-    message["command"] = command;
+/* 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)));
 
-    ON_CALL(fileManager, isDownloading()).WillByDefault(testing::Return(true));
-    ON_CALL(fileManager, isUploading()).WillByDefault(testing::Return(true));
+  JsonCommander::Response response = jsonCommander.execute(message);
 
-    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_EQ(response.json["response"].asString(), "download and upload running");
+    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