|
|
@@ -0,0 +1,2412 @@
|
|
|
+#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 */
|
Sander, Paul