CCats/cli/test/cmdman_test.cpp

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

#include "../include/cmdman.h"
#include "../include/global.h"
#include "fileman_mock.h"

#include "CmdManForTest.cpp"

/* template

TEST(testVersion, Positive) {
        FileManMock fm;
        CmdManForTest cm(fm, dummyDebugPrint);

        std::string cmd;
        std::vector<std::string> args;
        Json::Value root;
        CmdMan::CmdRet retval;

        // prepare root/cmd/args
        cmd = "";
        args = {"", ""};
        root[""] = "";

        // stick into cmdman
        cm.execute(cmd, args);
        cm.handle(root);

        // check things
        EXPECT_EQ(retval.type, sometypes);
        EXPECT_EQ(retval.nextcommand, somestring);
        EXPECT_TRUE(retval.msg[""].asBool());
        EXPECT_FALSE(retval.msg[""].asBool());
        ON_CALL(fm, methodname()).WillByDefault(testing::Return(true));
}

*/

/* holds all tests */
namespace {

void dummyDebugPrint(string x) {
	// do nothing
}

/*
 * =====================================
 * tests for connect
 */
TEST(testConnect, TooFewArgs) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);

	std::string cmd;
	std::vector<std::string> args;
	CmdMan::CmdRet retvalCmd;

	// prepare cmd/args
	cmd = "connect";
	args = {};

	// stick into cmdman
	retvalCmd = cm.execute(cmd, args);

	// check things
	EXPECT_EQ(retvalCmd.type, CmdMan::error);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "connect");
	EXPECT_FALSE(retvalCmd.msg["accept"].asBool());
	EXPECT_NE(retvalCmd.msg["error"].asString(), "");

	EXPECT_TRUE(cm.isNotConnected());
}

TEST(testConnect, Positive_NoPortSpecified) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);

	std::string cmd;
	std::vector<std::string> args;
	CmdMan::CmdRet retvalCmd;

	// prepare cmd/args
	cmd = "connect";
	args = {"1.222.33.4"};

	// stick into cmdman
	retvalCmd = cm.execute(cmd, args);
	cm.stateSetConnectionOk();

	// check things
	EXPECT_EQ(retvalCmd.type, CmdMan::connect);
	EXPECT_EQ(retvalCmd.msg["address"].asString(), "1.222.33.4");
	EXPECT_EQ(retvalCmd.msg["port"].asString(), "1234");

	EXPECT_TRUE(cm.isConnected());
}

TEST(testConnect, Positive_PortSpecified) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);

	std::string cmd;
	std::vector<std::string> args;
	CmdMan::CmdRet retvalCmd;

	// prepare cmd/args
	cmd = "connect";
	args = {"1.222.33.4", "1337"};

	// stick into cmdman
	retvalCmd = cm.execute(cmd, args);
	cm.stateSetConnectionOk();

	// check things
	EXPECT_EQ(retvalCmd.type, CmdMan::connect);
	EXPECT_EQ(retvalCmd.msg["address"].asString(), "1.222.33.4");
	EXPECT_EQ(retvalCmd.msg["port"].asString(), "1337");

	EXPECT_TRUE(cm.isConnected());
}

TEST(testConnect, Negative) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);

	std::string cmd;
	std::vector<std::string> args;
	CmdMan::CmdRet retvalCmd;

	// prepare cmd/args
	cmd = "connect";
	args = {"1.222.33.4", "1337"};

	// stick into cmdman
	retvalCmd = cm.execute(cmd, args);
	// cm.stateSetConnectionOk() not called

	// check things
	EXPECT_EQ(retvalCmd.type, CmdMan::connect);
	EXPECT_EQ(retvalCmd.msg["address"].asString(), "1.222.33.4");
	EXPECT_EQ(retvalCmd.msg["port"].asString(), "1337");

	EXPECT_TRUE(cm.isNotConnected());
}

/* =====================================
 * tests for
 * version check, signup, login
 */

TEST(testVersion, Positive) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initConnected();

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalCmd;
	CmdMan::CmdRet retvalHdl;

	// prepare root/cmd/args
	cmd = "version";
	args = {};
	root["major"] = protocolMajorVersion;
	root["minor"] = protocolMinorVersion;
	root["accept"] = true;

	// stick into cmdman
	retvalCmd = cm.execute(cmd, args);
	retvalHdl = cm.handle(root);

	// check things
	EXPECT_EQ(retvalCmd.type, CmdMan::send);
	EXPECT_EQ(retvalCmd.msg["major"], protocolMajorVersion);
	EXPECT_EQ(retvalCmd.msg["minor"], protocolMinorVersion);

	EXPECT_EQ(retvalHdl.type, CmdMan::print);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "version");
	EXPECT_EQ(retvalHdl.msg["serverversion"].asString(), std::to_string(protocolMajorVersion) + "." + std::to_string(protocolMinorVersion));
	EXPECT_EQ(retvalHdl.msg["clientversion"].asString(), std::to_string(protocolMajorVersion) + "." + std::to_string(protocolMinorVersion));
	EXPECT_TRUE(retvalHdl.msg["accept"].asBool());

	EXPECT_TRUE(cm.isVersionChecked());
}

TEST(testVersion, Negative) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initConnected();

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalCmd;
	CmdMan::CmdRet retvalHdl;
	int servermajor, serverminor;

	// prepare root/cmd/args
	cmd = "version";
	args = {};
	servermajor = (protocolMajorVersion == 0) ? 42 : 0;
	serverminor = (protocolMinorVersion == 3) ? 42 : 3;
	root["major"] = servermajor;
	root["minor"] = serverminor;
	root["accept"] = false;

	// stick into cmdman
	retvalCmd = cm.execute(cmd, args);
	retvalHdl = cm.handle(root);

	// check things
	EXPECT_EQ(retvalCmd.type, CmdMan::send);
	EXPECT_EQ(retvalCmd.msg["major"], protocolMajorVersion);
	EXPECT_EQ(retvalCmd.msg["minor"], protocolMinorVersion);

	EXPECT_EQ(retvalHdl.type, CmdMan::error | CmdMan::close);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "version");
	EXPECT_EQ(retvalHdl.msg["serverversion"].asString(), std::to_string(servermajor) + "." + std::to_string(serverminor));
	EXPECT_EQ(retvalHdl.msg["clientversion"].asString(), std::to_string(protocolMajorVersion) + "." + std::to_string(protocolMinorVersion));
	EXPECT_FALSE(retvalHdl.msg["accept"].asBool());

	EXPECT_TRUE(cm.isNotConnected());
}

TEST(testVersion, AlreadyLoggedIn) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalCmd;
	CmdMan::CmdRet retvalHdl;

	// prepare cmd/args
	cmd = "version";
	args = {};

	// stick into cmdman
	retvalCmd = cm.execute(cmd, args);

	// check things
	EXPECT_EQ(retvalCmd.type, CmdMan::error);
	// TODO: check some more things maybe

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testLogin, Positive) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initVersionChecked();

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalCmd;
	CmdMan::CmdRet retvalHdl;

	// prepare root/cmd/args
	cmd = "login";
	args = {"usernem", "paswod"};
	root["accept"] = true;

	// stick into cmdman
	retvalCmd = cm.execute(cmd, args);
	retvalHdl = cm.handle(root);

	// check things
	EXPECT_EQ(retvalCmd.type, CmdMan::send);
	EXPECT_TRUE(retvalCmd.msg["login"].asBool());
	EXPECT_EQ(retvalCmd.msg["user"].asString(), "usernem");
	EXPECT_EQ(retvalCmd.msg["pass"].asString(), "paswod");
	EXPECT_FALSE(retvalCmd.msg["cancel"].asBool());

	EXPECT_EQ(retvalHdl.type, CmdMan::print);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "login");
	EXPECT_TRUE(retvalHdl.msg["accept"].asBool());

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testLogin, Negative) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initVersionChecked();

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalCmd;
	CmdMan::CmdRet retvalHdl;

	// prepare root/cmd/args
	cmd = "login";
	args = {"usernem", "paswod"};
	root["accept"] = false;
	root["error"] = "fancy error string";

	// stick into cmdman
	retvalCmd = cm.execute(cmd, args);
	retvalHdl = cm.handle(root);

	// check things
	EXPECT_EQ(retvalCmd.type, CmdMan::send);
	EXPECT_TRUE(retvalCmd.msg["login"].asBool());
	EXPECT_EQ(retvalCmd.msg["user"].asString(), "usernem");
	EXPECT_EQ(retvalCmd.msg["pass"].asString(), "paswod");
	EXPECT_FALSE(retvalCmd.msg["cancel"].asBool());

	EXPECT_EQ(retvalHdl.type, CmdMan::error);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "login");
	EXPECT_FALSE(retvalHdl.msg["accept"].asBool());
	EXPECT_THAT(retvalHdl.msg["error"].asString(), testing::HasSubstr("fancy error string"));

	EXPECT_TRUE(cm.isVersionChecked());
}

TEST(testLogin, TooFewArgs) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initVersionChecked();

	std::string cmd;
	std::vector<std::string> args;
	CmdMan::CmdRet retvalCmd;

	// prepare cmd/args
	cmd = "login";
	args = {"usernem"};

	// stick into cmdman
	retvalCmd = cm.execute(cmd, args);

	// check things
	EXPECT_EQ(retvalCmd.type, CmdMan::error);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "login");
	EXPECT_FALSE(retvalCmd.msg["accept"].asBool());
	EXPECT_NE(retvalCmd.msg["error"].asString(), "");

	EXPECT_TRUE(cm.isVersionChecked());
}

TEST(testLogin, AlreadyLoggedIn) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	CmdMan::CmdRet retvalCmd;

	// prepare root/cmd/args
	cmd = "login";
	args = {"usernem", "paswod"};

	// stick into cmdman
	retvalCmd = cm.execute(cmd, args);

	// check things
	EXPECT_EQ(retvalCmd.type, CmdMan::error);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "login");
	EXPECT_FALSE(retvalCmd.msg["accept"].asBool());
	EXPECT_NE(retvalCmd.msg["error"].asString(), "");

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testLogin, TwoRequestsInRow) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initVersionChecked();

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalCmd1;
	CmdMan::CmdRet retvalCmd2;
	CmdMan::CmdRet retvalHdl;

	// prepare root/cmd/args
	cmd = "login";
	args = {"usernem", "paswod"};
	root["accept"] = true;

	// stick into cmdman
	retvalCmd1 = cm.execute(cmd, args);
	retvalCmd2 = cm.execute(cmd, args);
	retvalHdl = cm.handle(root);

	// check things
	EXPECT_EQ(retvalCmd1.type, CmdMan::send);
	EXPECT_TRUE(retvalCmd1.msg["login"].asBool());
	EXPECT_EQ(retvalCmd1.msg["user"].asString(), "usernem");
	EXPECT_EQ(retvalCmd1.msg["pass"].asString(), "paswod");
	EXPECT_FALSE(retvalCmd1.msg["cancel"].asBool());

	EXPECT_EQ(retvalCmd2.type, CmdMan::error);
	EXPECT_EQ(retvalCmd2.msg["command"].asString(), "login");
	EXPECT_FALSE(retvalCmd2.msg["accept"].asBool());
	EXPECT_NE(retvalCmd2.msg["error"].asString(), "");

	EXPECT_EQ(retvalHdl.type, CmdMan::print);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "login");
	EXPECT_TRUE(retvalHdl.msg["accept"].asBool());

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testSignup, Positive) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initVersionChecked();

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalCmd;
	CmdMan::CmdRet retvalHdl;

	// prepare root/cmd/args
	cmd = "signup";
	args = {"usernem", "paswod"};
	root["accept"] = true;

	// stick into cmdman
	retvalCmd = cm.execute(cmd, args);
	retvalHdl = cm.handle(root);

	// check things
	EXPECT_EQ(retvalCmd.type, CmdMan::send);
	EXPECT_FALSE(retvalCmd.msg["login"].asBool());
	EXPECT_EQ(retvalCmd.msg["user"].asString(), "usernem");
	EXPECT_EQ(retvalCmd.msg["pass"].asString(), "paswod");
	EXPECT_FALSE(retvalCmd.msg["cancel"].asBool());

	EXPECT_EQ(retvalHdl.type, CmdMan::print);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "signup");
	EXPECT_TRUE(retvalHdl.msg["accept"].asBool());

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testSignup, Negative) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initVersionChecked();

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalCmd;
	CmdMan::CmdRet retvalHdl;

	// prepare root/cmd/args
	cmd = "signup";
	args = {"usernem", "paswod"};
	root["accept"] = false;
	root["error"] = "fancy error string";

	// stick into cmdman
	retvalCmd = cm.execute(cmd, args);
	retvalHdl = cm.handle(root);

	// check things
	EXPECT_EQ(retvalCmd.type, CmdMan::send);
	EXPECT_FALSE(retvalCmd.msg["login"].asBool());
	EXPECT_EQ(retvalCmd.msg["user"].asString(), "usernem");
	EXPECT_EQ(retvalCmd.msg["pass"].asString(), "paswod");
	EXPECT_FALSE(retvalCmd.msg["cancel"].asBool());

	EXPECT_EQ(retvalHdl.type, CmdMan::error);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "signup");
	EXPECT_FALSE(retvalHdl.msg["accept"].asBool());
	EXPECT_THAT(retvalHdl.msg["error"].asString(), testing::HasSubstr("fancy error string"));

	EXPECT_TRUE(cm.isVersionChecked());
}

TEST(testSignup, TooFewArgs) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initVersionChecked();

	std::string cmd;
	std::vector<std::string> args;
	CmdMan::CmdRet retvalCmd;

	// prepare cmd/args
	cmd = "signup";
	args = {"usernem"};

	// stick into cmdman
	retvalCmd = cm.execute(cmd, args);

	// check things
	EXPECT_EQ(retvalCmd.type, CmdMan::error);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "signup");
	EXPECT_FALSE(retvalCmd.msg["accept"].asBool());
	EXPECT_NE(retvalCmd.msg["error"].asString(), "");

	EXPECT_TRUE(cm.isVersionChecked());
}

/*
 * =====================================
 * tests for disconnect and exit
 */
TEST(testDisconnect, LoggedIn) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalCmd;
	CmdMan::CmdRet retvalHdl;

	// prepare root/cmd/args
	cmd = "disconnect";
	args = {};
	root["command"] = "close";
	root["response"] = "bye";

	// stick into cmdman
	retvalCmd = cm.execute(cmd, args);
	retvalHdl = cm.handle(root);

	// check things
	EXPECT_EQ(retvalCmd.type, CmdMan::send);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "close");

	EXPECT_EQ(retvalHdl.type, CmdMan::close | CmdMan::print);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "disconnect");
	EXPECT_TRUE(retvalHdl.msg["accept"].asBool());

	EXPECT_TRUE(cm.isNotConnected());
}

TEST(testDisconnect, NotLoggedIn) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initVersionChecked();

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalCmd;
	CmdMan::CmdRet retvalHdl;

	// prepare root/cmd/args
	cmd = "disconnect";
	args = {};

	// stick into cmdman
	retvalCmd = cm.execute(cmd, args);

	// check things
	EXPECT_EQ(retvalCmd.type, CmdMan::send | CmdMan::close);
	EXPECT_FALSE(retvalCmd.msg["login"].asBool());
	EXPECT_EQ(retvalCmd.msg["user"].asString(), "");
	EXPECT_EQ(retvalCmd.msg["pass"].asString(), "");
	EXPECT_TRUE(retvalCmd.msg["cancel"].asBool());

	EXPECT_TRUE(cm.isNotConnected());
}

TEST(testExit, LoggedIn) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalCmdExit;
	CmdMan::CmdRet retvalCmdDisconnect;
	CmdMan::CmdRet retvalHdl;
	CmdMan::CmdRet retvalLastExit;

	// prepare root/cmd/args
	cmd = "exit";
	args = {};
	root["command"] = "close";
	root["response"] = "bye";

	// stick into cmdman and check things
	retvalCmdExit = cm.execute(cmd, args);

	EXPECT_EQ(retvalCmdExit.type, CmdMan::none);
	EXPECT_EQ(retvalCmdExit.nextcommand, "disconnect");

	retvalCmdDisconnect = cm.execute("disconnect", args);

	EXPECT_EQ(retvalCmdDisconnect.type, CmdMan::send);
	EXPECT_EQ(retvalCmdDisconnect.msg["command"].asString(), "close");

	retvalHdl = cm.handle(root);

	EXPECT_EQ(retvalHdl.type, CmdMan::close | CmdMan::print);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "disconnect");
	EXPECT_TRUE(retvalHdl.msg["accept"].asBool());
	EXPECT_EQ(retvalHdl.nextcommand, "exit");

	EXPECT_TRUE(cm.isNotConnected());

	retvalLastExit = cm.execute("exit", args);

	EXPECT_EQ(retvalLastExit.type, CmdMan::exit);
	EXPECT_EQ(retvalLastExit.msg["command"].asString(), "exit");
}

TEST(testExit, NotLoggedIn) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initVersionChecked();

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalCmdExit;
	CmdMan::CmdRet retvalCmdDisconnect;
	CmdMan::CmdRet retvalHdl;
	CmdMan::CmdRet retvalLastExit;

	// prepare root/cmd/args
	cmd = "exit";
	args = {};
	root["command"] = "close";
	root["response"] = "bye";

	// stick into cmdman and check things
	retvalCmdExit = cm.execute(cmd, args);

	EXPECT_EQ(retvalCmdExit.type, CmdMan::none);
	EXPECT_EQ(retvalCmdExit.nextcommand, "disconnect");

	retvalCmdDisconnect = cm.execute("disconnect", args);

	EXPECT_EQ(retvalCmdDisconnect.type, CmdMan::send | CmdMan::close);
	EXPECT_FALSE(retvalCmdDisconnect.msg["login"].asBool());
	EXPECT_EQ(retvalCmdDisconnect.msg["user"].asString(), "");
	EXPECT_EQ(retvalCmdDisconnect.msg["pass"].asString(), "");
	EXPECT_TRUE(retvalCmdDisconnect.msg["cancel"].asBool());
	EXPECT_EQ(retvalCmdDisconnect.nextcommand, "exit");

	EXPECT_TRUE(cm.isNotConnected());

	retvalLastExit = cm.execute("exit", args);

	EXPECT_EQ(retvalLastExit.type, CmdMan::exit);
	EXPECT_EQ(retvalLastExit.msg["command"].asString(), "exit");
}

TEST(testExit, NotConnected) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);

	std::string cmd;
	std::vector<std::string> args;
	CmdMan::CmdRet retvalCmd;

	// prepare root/cmd/args
	cmd = "exit";
	args = {};

	// stick into cmdman and check things
	retvalCmd = cm.execute(cmd, args);

	EXPECT_EQ(retvalCmd.type, CmdMan::exit);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "exit");
}

/* =====================================
 * tests for put[data]
 */

TEST(testPut, TooFewArgs) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	CmdMan::CmdRet retvalCmd;

	// prepare cmd/args
	cmd = "put";
	args = {};

	// stick into cmdman
	retvalCmd = cm.execute(cmd, args);

	// check things
	EXPECT_EQ(retvalCmd.type, CmdMan::error);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "put");
	EXPECT_FALSE(retvalCmd.msg["accept"].asBool());
	EXPECT_NE(retvalCmd.msg["error"].asString(), "");

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testPut, Positive) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalCmd;
	CmdMan::CmdRet retvalHdl;

	// prepare root/cmd/args
	cmd = "put";
	args = {"../some/nice/filepath/filename.txt"};
	root["command"] = "put";
	root["file"] = "filename.txt";
	root["accept"] = true;

	EXPECT_CALL(fm, openPut(testing::_)).WillOnce(testing::Return(true));
	ON_CALL(fm, getPutSize()).WillByDefault(testing::Return(5));
	ON_CALL(fm, getPutChunks()).WillByDefault(testing::Return(1));
	ON_CALL(fm, getPutName()).WillByDefault(testing::Return("filename.txt"));

	EXPECT_CALL(fm, cancelGet).Times(0); // not called

	// stick into cmdman and check things
	retvalCmd = cm.execute(cmd, args);

	EXPECT_EQ(retvalCmd.type, CmdMan::send);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "put");
	EXPECT_EQ(retvalCmd.msg["file"].asString(), "filename.txt");
	EXPECT_EQ(retvalCmd.msg["size"].asInt(), 5);
	EXPECT_EQ(retvalCmd.msg["chunks"].asInt(), 1);

	EXPECT_CALL(fm, isPutting()).WillOnce(testing::Return(true));

	retvalHdl = cm.handle(root);

	EXPECT_EQ(retvalHdl.type, CmdMan::print | CmdMan::send);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "put");
	EXPECT_TRUE(retvalHdl.msg["accept"].asBool());
	EXPECT_EQ(retvalHdl.msg["file"].asString(), "filename.txt");
	EXPECT_EQ(retvalHdl.nextcommand, "putdata");

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testPutdata, Positive_LastChunk) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalCmd;
	CmdMan::CmdRet retvalHdl;

	/**logically continuation of TEST(testPut, Positive)**/

	// prepare root/cmd/args
	cmd = "putdata";
	args = {};
	root["command"] = "putdata";
	root["file"] = "filename.txt";
	root["received"] = 0;
	root["cancel"] = false;

	ON_CALL(fm, getPutName()).WillByDefault(testing::Return("filename.txt"));
	ON_CALL(fm, readBase64()).WillByDefault(testing::Return("cool Base64 string"));
	ON_CALL(fm, getPutRemainingChunks()).WillByDefault(testing::Return(0));
	EXPECT_CALL(fm, isPutting()).WillOnce(testing::Return(true));

	EXPECT_CALL(fm, cancelPut).Times(0); // not called
	EXPECT_CALL(fm, closePut);

	// stick into cmdman and check things
	retvalCmd = cm.execute(cmd, args);

	EXPECT_EQ(retvalCmd.type, CmdMan::send);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "putdata");
	EXPECT_EQ(retvalCmd.msg["file"].asString(), "filename.txt");
	EXPECT_EQ(retvalCmd.msg["data"].asString(), "cool Base64 string");
	EXPECT_EQ(retvalCmd.msg["remaining"].asInt(), 0);
	EXPECT_FALSE(retvalCmd.msg["cancel"].asBool());

	EXPECT_CALL(fm, isPutting()).WillOnce(testing::Return(true));
	retvalHdl = cm.handle(root);

	EXPECT_EQ(retvalHdl.type, CmdMan::print);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "putdata");
	EXPECT_FALSE(retvalHdl.msg["cancel"].asBool());
	EXPECT_EQ(retvalHdl.msg["speed"].asInt(), 0);
	EXPECT_EQ(retvalHdl.msg["file"].asString(), "filename.txt");
	EXPECT_EQ(retvalHdl.msg["error"].asString(), "");

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testPutdata, Positive_ChunksRemaining) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalCmd;
	CmdMan::CmdRet retvalHdl;

	// prepare root/cmd/args
	cmd = "putdata";
	args = {};
	root["command"] = "putdata";
	root["file"] = "filename.txt";
	root["received"] = 42;
	root["cancel"] = false;

	ON_CALL(fm, getPutName()).WillByDefault(testing::Return("filename.txt"));
	ON_CALL(fm, readBase64()).WillByDefault(testing::Return("cool Base64 string"));
	ON_CALL(fm, getPutRemainingChunks()).WillByDefault(testing::Return(42));
	EXPECT_CALL(fm, isPutting()).WillOnce(testing::Return(true));

	EXPECT_CALL(fm, cancelGet).Times(0); // not called

	// stick into cmdman and check things
	retvalCmd = cm.execute(cmd, args);

	EXPECT_EQ(retvalCmd.type, CmdMan::send);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "putdata");
	EXPECT_EQ(retvalCmd.msg["file"].asString(), "filename.txt");
	EXPECT_EQ(retvalCmd.msg["data"].asString(), "cool Base64 string");
	EXPECT_EQ(retvalCmd.msg["remaining"].asInt(), 42);
	EXPECT_FALSE(retvalCmd.msg["cancel"].asBool());

	EXPECT_CALL(fm, isPutting()).WillOnce(testing::Return(true));
	retvalHdl = cm.handle(root);

	EXPECT_EQ(retvalHdl.type, CmdMan::print | CmdMan::send);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "putdata");
	EXPECT_FALSE(retvalHdl.msg["cancel"].asBool());
	EXPECT_EQ(retvalHdl.msg["speed"].asInt(), 0);
	EXPECT_EQ(retvalHdl.msg["file"].asString(), "filename.txt");
	EXPECT_EQ(retvalHdl.msg["error"].asString(), "");
	EXPECT_EQ(retvalHdl.nextcommand, "putdata");

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testPut, Negative_FileNotExisting) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalCmd;
	CmdMan::CmdRet retvalHdl;

	// prepare root/cmd/args
	cmd = "put";
	args = {"../some/nice/filepath/filename.txt"};

	EXPECT_CALL(fm, openPut(testing::_)).WillOnce(testing::Return(false));
	ON_CALL(fm, pathToFilename("../some/nice/filepath/filename.txt")).WillByDefault(testing::Return("filename.txt"));

	// stick into cmdman and check things
	retvalCmd = cm.execute(cmd, args);

	EXPECT_EQ(retvalCmd.type, CmdMan::error);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "put");
	EXPECT_EQ(retvalCmd.msg["file"].asString(), "filename.txt");
	EXPECT_NE(retvalCmd.msg["error"].asString(), "");

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testPut, Negative_ServerError) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	/* tests the handling of server reply only,
	 * initial request assumed as correct (tested in other tests) */

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalHdl;

	// prepare root
	root["command"] = "put";
	root["file"] = "filename.txt";
	root["accept"] = false;
	root["error"] = "foobar";

	ON_CALL(fm, getPutSize()).WillByDefault(testing::Return(5));
	ON_CALL(fm, getPutChunks()).WillByDefault(testing::Return(1));
	ON_CALL(fm, getPutName()).WillByDefault(testing::Return("filename.txt"));

	EXPECT_CALL(fm, cancelPut);

	retvalHdl = cm.handle(root);

	EXPECT_EQ(retvalHdl.type, CmdMan::error);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "put");
	EXPECT_FALSE(retvalHdl.msg["accept"].asBool());
	EXPECT_EQ(retvalHdl.msg["file"].asString(), "filename.txt");
	EXPECT_THAT(retvalHdl.msg["error"].asString(), testing::HasSubstr("foobar"));

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testPut, Negative_ServerWrongFile) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	/* tests the handling of server reply only,
	 * initial request assumed as correct (tested in other tests) */

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalHdl;

	// prepare root
	root["command"] = "put";
	root["file"] = "completely_different_filename.txt";
	root["accept"] = true;

	ON_CALL(fm, getPutSize()).WillByDefault(testing::Return(5));
	ON_CALL(fm, getPutChunks()).WillByDefault(testing::Return(1));
	ON_CALL(fm, getPutName()).WillByDefault(testing::Return("filename.txt"));

	EXPECT_CALL(fm, isPutting()).WillOnce(testing::Return(true));
	EXPECT_CALL(fm, cancelPut);

	retvalHdl = cm.handle(root);

	EXPECT_EQ(retvalHdl.type, CmdMan::error);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "put");
	EXPECT_FALSE(retvalHdl.msg["accept"].asBool());
	EXPECT_EQ(retvalHdl.msg["file"].asString(), "filename.txt");
	EXPECT_NE(retvalHdl.msg["error"].asString(), "");

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testPutdata, Negative_ServerError) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	/* tests the handling of server reply only,
	 * initial request assumed as correct (tested in other tests) */

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalHdl;

	// prepare root
	root["command"] = "putdata";
	root["file"] = "filename.txt";
	root["received"] = 42;
	root["cancel"] = true;
	root["error"] = "cool foobar";

	ON_CALL(fm, getPutName()).WillByDefault(testing::Return("filename.txt"));
	ON_CALL(fm, getPutRemainingChunks()).WillByDefault(testing::Return(42));
	ON_CALL(fm, isPutting()).WillByDefault(testing::Return(true));
	retvalHdl = cm.handle(root);

	EXPECT_CALL(fm, cancelPut);

	retvalHdl = cm.handle(root);

	EXPECT_EQ(retvalHdl.type, CmdMan::error);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "putdata");
	EXPECT_TRUE(retvalHdl.msg["cancel"].asBool());
	EXPECT_EQ(retvalHdl.msg["file"].asString(), "filename.txt");
	EXPECT_THAT(retvalHdl.msg["error"].asString(), testing::HasSubstr("cool foobar"));

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testPutdata, Negative_ServerWrongFile) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	/* tests the handling of server reply only,
	 * initial request assumed as correct (tested in other tests) */

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalHdl;

	// prepare root
	root["command"] = "putdata";
	root["file"] = "completely_different_filename.txt";
	root["received"] = 42;
	root["cancel"] = false;

	ON_CALL(fm, getPutName()).WillByDefault(testing::Return("filename.txt"));
	ON_CALL(fm, getPutRemainingChunks()).WillByDefault(testing::Return(42));
	EXPECT_CALL(fm, isPutting()).WillOnce(testing::Return(true));

	EXPECT_CALL(fm, cancelPut);

	retvalHdl = cm.handle(root);

	EXPECT_EQ(retvalHdl.type, CmdMan::error);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "putdata");
	EXPECT_TRUE(retvalHdl.msg["cancel"].asBool());
	EXPECT_EQ(retvalHdl.msg["file"].asString(), "filename.txt");
	EXPECT_NE(retvalHdl.msg["error"].asString(), "");

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testPutdata, Negative_ServerWrongChunkNumber) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	/* tests the handling of server reply only,
	 * initial request assumed as correct (tested in other tests) */

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalHdl;

	// prepare root
	root["command"] = "putdata";
	root["file"] = "filename.txt";
	root["received"] = 23;
	root["cancel"] = false;

	ON_CALL(fm, getPutName()).WillByDefault(testing::Return("filename.txt"));
	ON_CALL(fm, getPutRemainingChunks()).WillByDefault(testing::Return(42));
	EXPECT_CALL(fm, isPutting()).WillOnce(testing::Return(true));

	EXPECT_CALL(fm, cancelPut);

	retvalHdl = cm.handle(root);

	EXPECT_EQ(retvalHdl.type, CmdMan::error);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "putdata");
	EXPECT_TRUE(retvalHdl.msg["cancel"].asBool());
	EXPECT_EQ(retvalHdl.msg["file"].asString(), "filename.txt");
	EXPECT_NE(retvalHdl.msg["error"].asString(), "");

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testPut, Negative_NoFileOpen_ServerMessage) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalCmd;
	CmdMan::CmdRet retvalHdl;

	// prepare root
	root["command"] = "put";
	root["file"] = "filename.txt";
	root["accept"] = true;

	// handle reply
	EXPECT_CALL(fm, isPutting()).WillOnce(testing::Return(false));
	retvalHdl = cm.handle(root);

	EXPECT_EQ(retvalHdl.type, CmdMan::error);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "put");
	EXPECT_NE(retvalHdl.msg["error"].asString(), "");

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testPutdata, Negative_NoFileOpen_ServerMessage) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalCmd;
	CmdMan::CmdRet retvalHdl;

	// prepare root
	root["command"] = "putdata";
	root["file"] = "filename.txt";
	root["received"] = 23;
	root["cancel"] = false;

	// handle reply
	EXPECT_CALL(fm, isPutting()).WillOnce(testing::Return(false));
	retvalHdl = cm.handle(root);

	EXPECT_EQ(retvalHdl.type, CmdMan::error);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "putdata");
	//	EXPECT_EQ(retvalHdl.msg["file"].asString(), "filename.txt"); // no guarantee should be given...
	EXPECT_NE(retvalHdl.msg["error"].asString(), "");

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testPutdata, Negative_NoFileOpen_UserRequest) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalCmd;
	CmdMan::CmdRet retvalHdl;

	// prepare root
	cmd = "putdata";
	args = {};

	EXPECT_CALL(fm, isPutting()).WillOnce(testing::Return(false));

	// stick into cmdman and check things
	retvalCmd = cm.execute(cmd, args);

	EXPECT_EQ(retvalCmd.type, CmdMan::error);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "putdata");
	EXPECT_NE(retvalCmd.msg["error"].asString(), "");

	EXPECT_TRUE(cm.isLoggedIn());
}

/* =====================================
 * tests for head
 */
TEST(testHead, TooFewArgs) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalCmd;
	CmdMan::CmdRet retvalHdl;

	// prepare cmd/args
	cmd = "head";
	args = {};

	// stick into cmdman and check things
	retvalCmd = cm.execute(cmd, args);

	EXPECT_EQ(retvalCmd.type, CmdMan::error);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "head");
	EXPECT_NE(retvalCmd.msg["error"].asString(), "");

	retvalHdl = cm.handle(root);

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testHead, Positive) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalCmd;
	CmdMan::CmdRet retvalHdl;

	// prepare root/cmd/args
	cmd = "head";
	args = {"filename.txt"};
	root["command"] = "head";
	root["file"] = "filename.txt";
	root["accept"] = true;
	root["data"] = "this string is 4 bytes (obviously)";

	// stick into cmdman and check things
	retvalCmd = cm.execute(cmd, args);

	EXPECT_EQ(retvalCmd.type, CmdMan::send);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "head");
	EXPECT_EQ(retvalCmd.msg["file"].asString(), "filename.txt");

	retvalHdl = cm.handle(root);

	EXPECT_EQ(retvalHdl.type, CmdMan::print);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "head");
	EXPECT_TRUE(retvalHdl.msg["accept"].asBool());
	EXPECT_EQ(retvalHdl.msg["file"].asString(), "filename.txt");
	EXPECT_EQ(retvalHdl.msg["data"].asString(), "this string is 4 bytes (obviously)");

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testHead, Negative) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalCmd;
	CmdMan::CmdRet retvalHdl;

	// prepare root/cmd/args
	cmd = "head";
	args = {"filename.txt"};
	root["command"] = "head";
	root["file"] = "filename.txt";
	root["accept"] = false;
	root["error"] = "this is a fancy error message";

	// stick into cmdman and check things
	retvalCmd = cm.execute(cmd, args);

	EXPECT_EQ(retvalCmd.type, CmdMan::send);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "head");
	EXPECT_EQ(retvalCmd.msg["file"].asString(), "filename.txt");

	retvalHdl = cm.handle(root);

	EXPECT_EQ(retvalHdl.type, CmdMan::error);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "head");
	EXPECT_FALSE(retvalHdl.msg["accept"].asBool());
	EXPECT_EQ(retvalHdl.msg["file"].asString(), "filename.txt");
	EXPECT_THAT(retvalHdl.msg["error"].asString(), testing::HasSubstr("this is a fancy error message"));

	EXPECT_TRUE(cm.isLoggedIn());
}

/* =====================================
 * tests for get[data]
 */

TEST(testGet, TooFewArgs) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	CmdMan::CmdRet retvalCmd;

	// prepare cmd/args
	cmd = "get";
	args = {};

	// stick into cmdman
	retvalCmd = cm.execute(cmd, args);

	// check things
	EXPECT_EQ(retvalCmd.type, CmdMan::error);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "get");
	EXPECT_FALSE(retvalCmd.msg["accept"].asBool());
	EXPECT_NE(retvalCmd.msg["error"].asString(), "");

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testGet, Positive) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalCmd;
	CmdMan::CmdRet retvalHdl;

	// prepare root/cmd/args
	cmd = "get";
	args = {"../some/nice/filepath/filename.txt"};
	root["command"] = "get";
	root["file"] = "filename.txt";
	root["accept"] = true;
	root["chunks"] = 42;

	EXPECT_CALL(fm, openGet("../some/nice/filepath/filename.txt")).WillOnce(testing::Return(true));
	ON_CALL(fm, getGetName()).WillByDefault(testing::Return("filename.txt"));

	EXPECT_CALL(fm, cancelGet).Times(0); // not called

	// stick into cmdman and check things
	retvalCmd = cm.execute(cmd, args);

	EXPECT_EQ(retvalCmd.type, CmdMan::send);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "get");
	EXPECT_EQ(retvalCmd.msg["file"].asString(), "filename.txt");

	EXPECT_CALL(fm, isGetting()).WillOnce(testing::Return(true));
	EXPECT_CALL(fm, setGetChunks(42));

	retvalHdl = cm.handle(root);

	EXPECT_EQ(retvalHdl.type, CmdMan::print | CmdMan::send);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "get");
	EXPECT_TRUE(retvalHdl.msg["accept"].asBool());
	EXPECT_EQ(retvalHdl.msg["file"].asString(), "filename.txt");
	EXPECT_EQ(retvalHdl.nextcommand, "getdata");

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testGetdata, Positive_LastChunk) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalCmd;
	CmdMan::CmdRet retvalHdl;

	/**logically continuation of TEST(testGet, Positive)**/

	// prepare root/cmd/args
	cmd = "getdata";
	args = {};
	root["command"] = "getdata";
	root["file"] = "filename.txt";
	root["remaining"] = 0;
	root["cancel"] = false;
	root["data"] = "cool Base64 string";

	ON_CALL(fm, getGetName()).WillByDefault(testing::Return("filename.txt"));
	EXPECT_CALL(fm, writeBase64("cool Base64 string"));
	ON_CALL(fm, getGetRemainingChunks()).WillByDefault(testing::Return(0));
	EXPECT_CALL(fm, isGetting()).WillOnce(testing::Return(true));

	EXPECT_CALL(fm, cancelGet).Times(0); // not called

	// stick into cmdman and check things
	retvalCmd = cm.execute(cmd, args);

	EXPECT_EQ(retvalCmd.type, CmdMan::send);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "getdata");
	EXPECT_EQ(retvalCmd.msg["file"].asString(), "filename.txt");
	EXPECT_EQ(retvalCmd.msg["chunk"].asInt(), 0);
	EXPECT_FALSE(retvalCmd.msg["cancel"].asBool());

	EXPECT_CALL(fm, isGetting()).WillOnce(testing::Return(true));
	retvalHdl = cm.handle(root);

	EXPECT_EQ(retvalHdl.type, CmdMan::print);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "getdata");
	EXPECT_FALSE(retvalHdl.msg["cancel"].asBool());
	EXPECT_EQ(retvalHdl.msg["speed"].asInt(), 0);
	EXPECT_EQ(retvalHdl.msg["file"].asString(), "filename.txt");
	EXPECT_EQ(retvalHdl.msg["error"].asString(), "");

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testGetdata, Positive_ChunksRemaining) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalCmd;
	CmdMan::CmdRet retvalHdl;

	// prepare root/cmd/args
	cmd = "getdata";
	args = {};
	root["command"] = "getdata";
	root["file"] = "filename.txt";
	root["remaining"] = 42;
	root["cancel"] = false;
	root["data"] = "cool Base64 string";

	ON_CALL(fm, getGetName()).WillByDefault(testing::Return("filename.txt"));
	EXPECT_CALL(fm, writeBase64("cool Base64 string"));
	ON_CALL(fm, getGetRemainingChunks()).WillByDefault(testing::Return(42));
	EXPECT_CALL(fm, isGetting()).WillOnce(testing::Return(true));

	EXPECT_CALL(fm, cancelGet).Times(0); // not called

	// stick into cmdman and check things
	retvalCmd = cm.execute(cmd, args);

	EXPECT_EQ(retvalCmd.type, CmdMan::send);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "getdata");
	EXPECT_EQ(retvalCmd.msg["file"].asString(), "filename.txt");
	EXPECT_EQ(retvalCmd.msg["chunk"].asInt(), 42);
	EXPECT_FALSE(retvalCmd.msg["cancel"].asBool());

	EXPECT_CALL(fm, isGetting()).WillOnce(testing::Return(true));
	retvalHdl = cm.handle(root);

	EXPECT_EQ(retvalHdl.type, CmdMan::print | CmdMan::send);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "getdata");
	EXPECT_FALSE(retvalHdl.msg["cancel"].asBool());
	EXPECT_EQ(retvalHdl.msg["speed"].asInt(), 0);
	EXPECT_EQ(retvalHdl.msg["file"].asString(), "filename.txt");
	EXPECT_EQ(retvalHdl.msg["error"].asString(), "");
	EXPECT_EQ(retvalHdl.nextcommand, "getdata");

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testGet, Negative_FileAlreadyExisting) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalCmd;
	CmdMan::CmdRet retvalHdl;

	// prepare root/cmd/args
	cmd = "get";
	args = {"../some/nice/filepath/filename.txt"};

	EXPECT_CALL(fm, openGet(testing::_)).WillOnce(testing::Return(false));
	ON_CALL(fm, pathToFilename("../some/nice/filepath/filename.txt")).WillByDefault(testing::Return("filename.txt"));

	// stick into cmdman and check things
	retvalCmd = cm.execute(cmd, args);

	EXPECT_EQ(retvalCmd.type, CmdMan::error);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "get");
	EXPECT_EQ(retvalCmd.msg["file"].asString(), "filename.txt");
	EXPECT_NE(retvalCmd.msg["error"].asString(), "");

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testGet, Negative_ServerError) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	/* tests the handling of server reply only,
	 * initial request assumed as correct (tested in other tests) */

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalHdl;

	// prepare root
	root["command"] = "get";
	root["file"] = "filename.txt";
	root["accept"] = false;
	root["error"] = "foobar";

	ON_CALL(fm, getGetName()).WillByDefault(testing::Return("filename.txt"));
	EXPECT_CALL(fm, cancelGet());

	retvalHdl = cm.handle(root);

	EXPECT_EQ(retvalHdl.type, CmdMan::error);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "get");
	EXPECT_FALSE(retvalHdl.msg["accept"].asBool());
	EXPECT_EQ(retvalHdl.msg["file"].asString(), "filename.txt");
	EXPECT_NE(retvalHdl.msg["error"].asString(), "");

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testGet, Negative_ServerWrongFile) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	/* tests the handling of server reply only,
	 * initial request assumed as correct (tested in other tests) */

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalHdl;

	// prepare root
	root["command"] = "get";
	root["file"] = "completely_different_filename.txt";
	root["accept"] = true;

	ON_CALL(fm, getGetName()).WillByDefault(testing::Return("filename.txt"));

	EXPECT_CALL(fm, isGetting()).WillOnce(testing::Return(true));
	EXPECT_CALL(fm, cancelGet);

	retvalHdl = cm.handle(root);

	EXPECT_EQ(retvalHdl.type, CmdMan::error);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "get");
	EXPECT_FALSE(retvalHdl.msg["accept"].asBool());
	EXPECT_EQ(retvalHdl.msg["file"].asString(), "filename.txt");
	EXPECT_NE(retvalHdl.msg["error"].asString(), "");

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testGetdata, Negative_ServerError) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	/* tests the handling of server reply only,
	 * initial request assumed as correct (tested in other tests) */

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalHdl;

	// prepare root
	root["command"] = "getdata";
	root["file"] = "filename.txt";
	root["remaining"] = 42;
	root["cancel"] = true;
	root["error"] = "fancy foobar";

	ON_CALL(fm, getGetName()).WillByDefault(testing::Return("filename.txt"));
	ON_CALL(fm, getGetRemainingChunks()).WillByDefault(testing::Return(42));
	ON_CALL(fm, isGetting()).WillByDefault(testing::Return(true));
	retvalHdl = cm.handle(root);

	EXPECT_CALL(fm, cancelGet);

	retvalHdl = cm.handle(root);

	EXPECT_EQ(retvalHdl.type, CmdMan::error);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "getdata");
	EXPECT_TRUE(retvalHdl.msg["cancel"].asBool());
	EXPECT_EQ(retvalHdl.msg["file"].asString(), "filename.txt");
	EXPECT_THAT(retvalHdl.msg["error"].asString(), testing::HasSubstr("fancy foobar"));

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testGetdata, Negative_ServerWrongFile) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	/* tests the handling of server reply only,
	 * initial request assumed as correct (tested in other tests) */

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalHdl;

	// prepare root
	root["command"] = "getdata";
	root["file"] = "completely_different_filename.txt";
	root["remaining"] = 42;
	root["cancel"] = false;

	ON_CALL(fm, getGetName()).WillByDefault(testing::Return("filename.txt"));
	ON_CALL(fm, getGetRemainingChunks()).WillByDefault(testing::Return(42));
	ON_CALL(fm, isGetting()).WillByDefault(testing::Return(true));
	retvalHdl = cm.handle(root);

	EXPECT_CALL(fm, cancelGet);

	retvalHdl = cm.handle(root);

	EXPECT_EQ(retvalHdl.type, CmdMan::error);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "getdata");
	EXPECT_TRUE(retvalHdl.msg["cancel"].asBool());
	EXPECT_EQ(retvalHdl.msg["file"].asString(), "filename.txt");
	EXPECT_NE(retvalHdl.msg["error"].asString(), "");

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testGetdata, Negative_ServerWrongChunkNumber) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	/* tests the handling of server reply only,
	 * initial request assumed as correct (tested in other tests) */

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalHdl;

	// prepare root
	root["command"] = "getdata";
	root["file"] = "filename.txt";
	root["remaining"] = 23;
	root["cancel"] = false;

	ON_CALL(fm, getGetName()).WillByDefault(testing::Return("filename.txt"));
	ON_CALL(fm, getGetRemainingChunks()).WillByDefault(testing::Return(42));
	ON_CALL(fm, isGetting()).WillByDefault(testing::Return(true));
	retvalHdl = cm.handle(root);

	EXPECT_CALL(fm, cancelGet);

	retvalHdl = cm.handle(root);

	EXPECT_EQ(retvalHdl.type, CmdMan::error);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "getdata");
	EXPECT_TRUE(retvalHdl.msg["cancel"].asBool());
	EXPECT_EQ(retvalHdl.msg["file"].asString(), "filename.txt");
	EXPECT_NE(retvalHdl.msg["error"].asString(), "");

	EXPECT_TRUE(cm.isLoggedIn());
}

/* =====================================
 * tests for list[data]
 */

TEST(testList, Positive) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalCmd;
	CmdMan::CmdRet retvalHdl;

	// prepare root/cmd/args
	cmd = "list";
	args = {};
	root["command"] = "list";
	root["accept"] = true;
	root["items"] = 92;
	root["chunks"] = 2;

	EXPECT_CALL(fm, openList).WillOnce(testing::Return(true));

	EXPECT_CALL(fm, cancelList).Times(0); // not called

	// stick into cmdman and check things
	retvalCmd = cm.execute(cmd, args);

	EXPECT_EQ(retvalCmd.type, CmdMan::send);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "list");

	EXPECT_CALL(fm, isListing()).WillOnce(testing::Return(true));
	EXPECT_CALL(fm, setListChunks(2));

	retvalHdl = cm.handle(root);

	EXPECT_EQ(retvalHdl.type, CmdMan::send);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "list");
	EXPECT_TRUE(retvalHdl.msg["accept"].asBool());
	EXPECT_EQ(retvalHdl.nextcommand, "listdata");

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testListdata, Positive_ChunksRemaining) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root, namesArr;
	vector<string> namevec = {"blue.txt", "red.pdf", "green.sh", "yellow.tgz"};
	CmdMan::CmdRet retvalCmd;
	CmdMan::CmdRet retvalHdl;

	// prepare root/cmd/args
	cmd = "listdata";
	args = {};
	root["command"] = "listdata";
	root["cancel"] = false;
	root["remaining"] = 3;
	for (string s : namevec)
		namesArr.append(s);
	root["names"] = namesArr;

	EXPECT_CALL(fm, getListRemainingChunks).Times(2).WillRepeatedly(testing::Return(3));
	EXPECT_CALL(fm, isListing).Times(2).WillRepeatedly(testing::Return(true));

	EXPECT_CALL(fm, cancelList).Times(0); // not called

	// stick into cmdman and check things
	retvalCmd = cm.execute(cmd, args);

	EXPECT_EQ(retvalCmd.type, CmdMan::send);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "listdata");
	EXPECT_EQ(retvalCmd.msg["chunk"].asInt(), 3);
	EXPECT_EQ(retvalCmd.msg["cancel"].asBool(), false);

	vector<string> vec{"blue.txt", "red.pdf", "green.sh", "yellow.tgz"};
	EXPECT_CALL(fm, putListData(vec));

	retvalHdl = cm.handle(root);

	EXPECT_EQ(retvalHdl.type, CmdMan::send);
	EXPECT_EQ(retvalHdl.nextcommand, "listdata");

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testListdata, Positive_LastChunk) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root, namesArr;
	CmdMan::CmdRet retvalCmd;
	CmdMan::CmdRet retvalHdl;

	// prepare root/cmd/args
	cmd = "listdata";
	args = {};
	root["command"] = "listdata";
	root["cancel"] = false;
	root["remaining"] = 0;
	namesArr.append("magenta.vcd");
	root["names"] = namesArr;

	EXPECT_CALL(fm, getListRemainingChunks).Times(2).WillRepeatedly(testing::Return(0));
	EXPECT_CALL(fm, isListing).Times(2).WillRepeatedly(testing::Return(true));

	EXPECT_CALL(fm, cancelList).Times(0); // not called

	// stick into cmdman and check things
	retvalCmd = cm.execute(cmd, args);

	EXPECT_EQ(retvalCmd.type, CmdMan::send);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "listdata");
	EXPECT_EQ(retvalCmd.msg["chunk"].asInt(), 0);
	EXPECT_EQ(retvalCmd.msg["cancel"].asBool(), false);

	vector<string> vec{"magenta.vcd"};
	EXPECT_CALL(fm, putListData(vec));
	EXPECT_CALL(fm, closeList);
	vector<string> allFiles{"blue.txt", "red.pdf", "green.sh", "yellow.tgz", "cyan.exe", "white", "black", "magenta.vcd"};
	EXPECT_CALL(fm, getListData).WillOnce(testing::Return(allFiles));

	retvalHdl = cm.handle(root);
	// convert returned json value into vector
	vector<string> retval_msg_names;
	for (Json::Value i : retvalHdl.msg["names"])
		retval_msg_names.push_back(i.asString());

	EXPECT_EQ(retvalHdl.type, CmdMan::print);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "list");
	EXPECT_TRUE(retvalHdl.msg["accept"].asBool());
	EXPECT_EQ(retval_msg_names, allFiles);

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testList, Negative_ListEmpty) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalCmd;
	CmdMan::CmdRet retvalHdl;

	// prepare root/cmd/args
	cmd = "list";
	args = {};
	root["command"] = "list";
	root["accept"] = false;
	root["error"] = "no chunks to send";

	// stick into cmdman and check things
	EXPECT_CALL(fm, openList).WillOnce(testing::Return(true));
	retvalCmd = cm.execute(cmd, args);

	EXPECT_EQ(retvalCmd.type, CmdMan::send);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "list");

	EXPECT_CALL(fm, cancelList);
	retvalHdl = cm.handle(root);

	EXPECT_EQ(retvalHdl.type, CmdMan::error);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "list");
	EXPECT_FALSE(retvalHdl.msg["accept"].asBool());
	EXPECT_THAT(retvalHdl.msg["error"].asString(), testing::HasSubstr("no chunks to send"));

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testListdata, Negative) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	/* tests the handling of server reply only,
	 * initial request assumed as correct (tested in other tests) */

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalHdl;

	// prepare root/cmd/args
	root["command"] = "listdata";
	root["cancel"] = true;
	root["error"] = "some foobar";

	EXPECT_CALL(fm, cancelList);

	retvalHdl = cm.handle(root);

	EXPECT_EQ(retvalHdl.type, CmdMan::error);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "list");
	EXPECT_FALSE(retvalHdl.msg["accept"].asBool());
	EXPECT_THAT(retvalHdl.msg["error"].asString(), testing::HasSubstr("some foobar"));

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testList, Negative_AlreadyListing) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalCmd;

	// prepare cmd/args
	cmd = "list";
	args = {};

	EXPECT_CALL(fm, openList).WillOnce(testing::Return(false));

	EXPECT_CALL(fm, cancelList).Times(0); // not called

	// stick into cmdman and check things
	retvalCmd = cm.execute(cmd, args);

	EXPECT_EQ(retvalCmd.type, CmdMan::error);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "list");
	EXPECT_FALSE(retvalCmd.msg["accept"].asBool());
	EXPECT_NE(retvalCmd.msg["error"].asString(), "");

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testList, Negative_NotListing_ServerRequest) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root, namesArr;
	CmdMan::CmdRet retvalHdl;

	// prepare root
	root["command"] = "listdata";
	root["cancel"] = false;
	root["remaining"] = 0;
	namesArr.append("magenta.vcd");
	root["names"] = namesArr;

	EXPECT_CALL(fm, cancelList).Times(0);
	EXPECT_CALL(fm, putListData).Times(0);
	EXPECT_CALL(fm, closeList).Times(0);
	EXPECT_CALL(fm, getListData).Times(0);
	EXPECT_CALL(fm, isListing).WillOnce(testing::Return(false));

	retvalHdl = cm.handle(root);

	EXPECT_EQ(retvalHdl.type, CmdMan::error);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "list");
	EXPECT_FALSE(retvalHdl.msg["accept"].asBool());
	EXPECT_NE(retvalHdl.msg["error"].asString(), "");

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testListdata, Negative_NotListing_UserRequest) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	CmdMan::CmdRet retvalCmd;

	// prepare root/cmd/args
	cmd = "listdata";
	args = {};

	EXPECT_CALL(fm, isListing).WillOnce(testing::Return(false));

	// stick into cmdman and check things
	retvalCmd = cm.execute(cmd, args);

	EXPECT_EQ(retvalCmd.type, CmdMan::error);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "list");
	EXPECT_NE(retvalCmd.msg["error"].asString(), "");
	EXPECT_EQ(retvalCmd.msg["accept"].asBool(), false);
}

TEST(testListdata, Negative_NotListing_ServerRequest) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root, namesArr;
	CmdMan::CmdRet retvalHdl;

	// prepare root/cmd/args
	root["command"] = "listdata";
	root["cancel"] = false;
	root["remaining"] = 0;
	namesArr.append("magenta.vcd");
	root["names"] = namesArr;

	EXPECT_CALL(fm, cancelList).Times(0);

	retvalHdl = cm.handle(root);

	EXPECT_EQ(retvalHdl.type, CmdMan::error);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "list");
	EXPECT_FALSE(retvalHdl.msg["accept"].asBool());
	EXPECT_NE(retvalHdl.msg["error"].asString(), "");

	EXPECT_TRUE(cm.isLoggedIn());
}

/* =====================================
 * tests for deleteme
 */

TEST(testDeleteme, TooFewArgs) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	CmdMan::CmdRet retvalCmd;

	// prepare cmd/args
	cmd = "deleteme";
	args = {};

	// stick into cmdman
	retvalCmd = cm.execute(cmd, args);

	// check things
	EXPECT_EQ(retvalCmd.type, CmdMan::error);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "deleteme");
	EXPECT_FALSE(retvalCmd.msg["accept"].asBool());
	EXPECT_NE(retvalCmd.msg["error"].asString(), "");

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testDeleteme, Positive) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalCmd;
	CmdMan::CmdRet retvalHdl;

	// prepare cmd/args/root
	cmd = "deleteme";
	args = {"myFancyPasswd"};
	root["command"] = "deleteme";
	root["accept"] = true;

	// stick into cmdman
	retvalCmd = cm.execute(cmd, args);
	retvalHdl = cm.handle(root);

	// check things
	EXPECT_EQ(retvalCmd.type, CmdMan::send);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "deleteme");
	EXPECT_EQ(retvalCmd.msg["pass"].asString(), "myFancyPasswd");
	EXPECT_EQ(retvalHdl.type, CmdMan::print | CmdMan::close);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "deleteme");
	EXPECT_TRUE(retvalHdl.msg["accept"].asBool());

	EXPECT_TRUE(cm.isNotConnected());
}

TEST(testDeleteme, Negative) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalCmd;
	CmdMan::CmdRet retvalHdl;

	// prepare cmd/args/root
	cmd = "deleteme";
	args = {"myFancyPasswd"};
	root["command"] = "deleteme";
	root["accept"] = false;
	root["error"] = "password incorrect";

	// stick into cmdman
	retvalCmd = cm.execute(cmd, args);
	retvalHdl = cm.handle(root);

	// check things
	EXPECT_EQ(retvalCmd.type, CmdMan::send);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "deleteme");
	EXPECT_EQ(retvalCmd.msg["pass"].asString(), "myFancyPasswd");
	EXPECT_EQ(retvalHdl.type, CmdMan::error);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "deleteme");
	EXPECT_FALSE(retvalHdl.msg["accept"].asBool());
	EXPECT_THAT(retvalHdl.msg["error"].asString(), testing::HasSubstr("password incorrect"));

	EXPECT_TRUE(cm.isLoggedIn());
}

/* =====================================
 * tests for deletefile
 */
TEST(testDeletefile, TooFewArgs) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	CmdMan::CmdRet retvalCmd;

	// prepare cmd/args
	cmd = "deletefile";
	args = {};

	// stick into cmdman
	retvalCmd = cm.execute(cmd, args);

	// check things
	EXPECT_EQ(retvalCmd.type, CmdMan::error);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "deletefile");
	EXPECT_FALSE(retvalCmd.msg["accept"].asBool());
	EXPECT_NE(retvalCmd.msg["error"].asString(), "");

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testDeletefile, Positive) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalCmd;
	CmdMan::CmdRet retvalHdl;

	// prepare cmd/args/root
	cmd = "deletefile";
	args = {"fancy_file.txt"};
	root["command"] = "deletefile";
	root["file"] = "fancy_file.txt";
	root["accept"] = true;

	// stick into cmdman
	retvalCmd = cm.execute(cmd, args);
	retvalHdl = cm.handle(root);

	// check things
	EXPECT_EQ(retvalCmd.type, CmdMan::send);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "deletefile");
	EXPECT_EQ(retvalCmd.msg["file"].asString(), "fancy_file.txt");
	EXPECT_EQ(retvalHdl.type, CmdMan::print);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "deletefile");
	EXPECT_TRUE(retvalHdl.msg["accept"].asBool());
	EXPECT_EQ(retvalHdl.msg["file"].asString(), "fancy_file.txt");

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testDeletefile, Negative) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalCmd;
	CmdMan::CmdRet retvalHdl;

	// prepare cmd/args/root
	cmd = "deletefile";
	args = {"fancy_file.txt"};
	root["command"] = "deletefile";
	root["file"] = "fancy_file.txt";
	root["accept"] = false;
	root["error"] = "file does not exist";

	// stick into cmdman
	retvalCmd = cm.execute(cmd, args);
	retvalHdl = cm.handle(root);

	// check things
	EXPECT_EQ(retvalCmd.type, CmdMan::send);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "deletefile");
	EXPECT_EQ(retvalCmd.msg["file"].asString(), "fancy_file.txt");
	EXPECT_EQ(retvalHdl.type, CmdMan::error);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "deletefile");
	EXPECT_FALSE(retvalHdl.msg["accept"].asBool());
	EXPECT_EQ(retvalHdl.msg["file"].asString(), "fancy_file.txt");
	EXPECT_THAT(retvalHdl.msg["error"].asString(), testing::HasSubstr("file does not exist"));

	EXPECT_TRUE(cm.isLoggedIn());
}

/* =====================================
 * test for status
 */
TEST(testStatus, Test) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	Json::Value root;
	CmdMan::CmdRet retvalCmd;
	CmdMan::CmdRet retvalHdl;

	// prepare cmd/args/root
	cmd = "status";
	args = {};
	root["command"] = "status";
	root["response"] = "fancy response";
	root["accept"] = true;

	// stick into cmdman
	retvalCmd = cm.execute(cmd, args);
	retvalHdl = cm.handle(root);

	// check things
	EXPECT_EQ(retvalCmd.type, CmdMan::send);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "status");
	EXPECT_EQ(retvalHdl.type, CmdMan::print);
	EXPECT_EQ(retvalHdl.msg["command"].asString(), "status");
	EXPECT_THAT(retvalHdl.msg["response"].asString(), testing::HasSubstr("fancy response"));

	EXPECT_TRUE(cm.isLoggedIn());
}

/* =====================================
 * tests for help
 */
TEST(testHelp, LoggedIn) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	CmdMan::CmdRet retvalCmd;

	// prepare cmd/args/root
	cmd = "help";
	args = {};

	// stick into cmdman
	retvalCmd = cm.execute(cmd, args);

	// check things
	EXPECT_EQ(retvalCmd.type, CmdMan::print);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "help");
	EXPECT_NE(retvalCmd.msg["names"], "");

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testHelp, NotConnected) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);

	std::string cmd;
	std::vector<std::string> args;
	CmdMan::CmdRet retvalCmd;

	// prepare cmd/args/root
	cmd = "help";
	args = {};

	// stick into cmdman
	retvalCmd = cm.execute(cmd, args);

	// check things
	EXPECT_EQ(retvalCmd.type, CmdMan::print);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "help");
	EXPECT_NE(retvalCmd.msg["names"], "");

	EXPECT_TRUE(cm.isNotConnected());
}

/* =====================================
 * tests for keyfile and closekey
 */
TEST(testKeyfile, TooFewArgs) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	CmdMan::CmdRet retvalCmd;

	// prepare cmd/args
	cmd = "keyfile";
	args = {};

	// stick into cmdman
	EXPECT_CALL(fm, openKey).Times(0);
	EXPECT_CALL(fm, getOpensslError).Times(0);
	retvalCmd = cm.execute(cmd, args);

	// check things
	EXPECT_EQ(retvalCmd.type, CmdMan::error);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "keyfile");
	EXPECT_FALSE(retvalCmd.msg["accept"].asBool());
	EXPECT_NE(retvalCmd.msg["error"].asString(), "");

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testKeyfile, Negative) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	CmdMan::CmdRet retvalCmd;

	// prepare cmd/args
	cmd = "keyfile";
	args = {"./some/path"};

	// stick into cmdman
	EXPECT_CALL(fm, openKey).WillOnce(testing::Return(false));
	EXPECT_CALL(fm, getOpensslError).WillOnce(testing::Return("some openssl error"));
	retvalCmd = cm.execute(cmd, args);

	// check things
	EXPECT_EQ(retvalCmd.type, CmdMan::error);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "keyfile");
	EXPECT_FALSE(retvalCmd.msg["accept"].asBool());
	EXPECT_EQ(retvalCmd.msg["file"].asString(), "./some/path");
	EXPECT_NE(retvalCmd.msg["error"].asString(), "");

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testKeyfile, Positive) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	CmdMan::CmdRet retvalCmd;

	// prepare cmd/args
	cmd = "keyfile";
	args = {"./some/path"};

	// stick into cmdman
	EXPECT_CALL(fm, openKey).WillOnce(testing::Return(true));
	EXPECT_CALL(fm, getOpensslError).Times(0);
	retvalCmd = cm.execute(cmd, args);

	// check things
	EXPECT_EQ(retvalCmd.type, CmdMan::print);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "keyfile");
	EXPECT_TRUE(retvalCmd.msg["accept"].asBool());
	EXPECT_EQ(retvalCmd.msg["file"].asString(), "./some/path");

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testClosekey, Positive) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	CmdMan::CmdRet retvalCmd;

	// prepare cmd/args
	cmd = "closekey";
	args = {};

	// stick into cmdman
	EXPECT_CALL(fm, closeKey).WillOnce(testing::Return(true));
	retvalCmd = cm.execute(cmd, args);

	// check things
	EXPECT_EQ(retvalCmd.type, CmdMan::print);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "closekey");
	EXPECT_TRUE(retvalCmd.msg["accept"].asBool());

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testClosekey, Negative) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	std::string cmd;
	std::vector<std::string> args;
	CmdMan::CmdRet retvalCmd;

	// prepare cmd/args
	cmd = "closekey";
	args = {};

	// stick into cmdman
	EXPECT_CALL(fm, closeKey).WillOnce(testing::Return(false));
	retvalCmd = cm.execute(cmd, args);

	// check things
	EXPECT_EQ(retvalCmd.type, CmdMan::error);
	EXPECT_EQ(retvalCmd.msg["command"].asString(), "closekey");
	EXPECT_FALSE(retvalCmd.msg["accept"].asBool());
	EXPECT_NE(retvalCmd.msg["error"].asString(), "");

	EXPECT_TRUE(cm.isLoggedIn());
}

TEST(testCommandsWithRequiredLogin, NotLoggedInOrNotConnected) {
	FileManMock fm;
	CmdManForTest cm(fm, dummyDebugPrint);
	cm.initLoggedIn();

	CmdMan::CmdRet retval1, retval2, retval3;

	// prepare cmd/args
	std::vector<std::string> cmds = {"put", "get", "list", "putdata", "getdata", "listdata", "head", "deletefile", "deleteme", "keyfile", "closekey"};
	// as every command works fine with too many args, we will simply pass three to all of them
	std::vector<std::string> args = {"arg1", "arg2", "arg3"};

	for (std::string cmd : cmds) {
		cm.initNotConnected();
		retval1 = cm.execute(cmd, args);
		cm.initConnected();
		retval2 = cm.execute(cmd, args);
		cm.initVersionChecked();
		retval3 = cm.execute(cmd, args);

		EXPECT_EQ(retval1.type, CmdMan::error);
		EXPECT_EQ(retval1.msg["command"].asString(), "error");
		EXPECT_NE(retval1.msg["error"].asString(), "");

		EXPECT_EQ(retval2.type, CmdMan::error);
		EXPECT_EQ(retval2.msg["command"].asString(), "error");
		EXPECT_NE(retval2.msg["error"].asString(), "");

		EXPECT_EQ(retval3.type, CmdMan::error);
		EXPECT_EQ(retval3.msg["command"].asString(), "error");
		EXPECT_NE(retval3.msg["error"].asString(), "");
	}
}

} // namespace
/* end of namespace */