Add unit tests for subMenuIcon parameter

    Add tests for addSubMenu request and addSubMenu resuming

    Related to APPLINK-23382

5 files changed, 335 insertions, 24 deletions

diff --git a/src/components/application_manager/test/commands/mobile/add_sub_menu_request_test.cc b/src/components/application_manager/test/commands/mobile/add_sub_menu_request_test.cc
index 95bcede5fa..a19a7eb403 100644
--- a/src/components/application_manager/test/commands/mobile/add_sub_menu_request_test.cc
+++ b/src/components/application_manager/test/commands/mobile/add_sub_menu_request_test.cc
@@ -59,18 +59,42 @@ using am::MockMessageHelper;
 using ::testing::_;
 using ::testing::Mock;
 using ::testing::Return;
+using ::testing::ReturnNull;
 
 typedef SharedPtr<AddSubMenuRequest> AddSubMenuPtr;
 
 namespace {
 const uint32_t kConnectionKey = 2u;
+const int32_t kMenuId = 5;
 }  // namespace
 
 class AddSubMenuRequestTest
     : public CommandRequestTest<CommandsTestMocks::kIsNice> {
- public:
+ protected:
   AddSubMenuRequestTest()
       : mock_message_helper_(*MockMessageHelper::message_helper_mock()) {}
+  void SetUp() OVERRIDE {
+    app = CreateMockApp();
+    command_msg_ = CreateMessage(smart_objects::SmartType_Map);
+
+    (*command_msg_)[am::strings::msg_params][am::strings::menu_id] = kMenuId;
+    (*command_msg_)[am::strings::params][am::strings::connection_key] =
+        kConnectionKey;
+
+    ON_CALL(app_mngr_, hmi_interfaces())
+        .WillByDefault(ReturnRef(hmi_interfaces_));
+
+    ON_CALL(hmi_interfaces_,
+            GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_UI))
+        .WillByDefault(Return(am::HmiInterfaces::STATE_AVAILABLE));
+
+    ON_CALL(hmi_interfaces_, GetInterfaceFromFunction(_))
+        .WillByDefault(Return(am::HmiInterfaces::HMI_INTERFACE_UI));
+  }
+  MockAppPtr app;
+  MessageSharedPtr command_msg_;
+
+  NiceMock<MockHmiInterfaces> hmi_interfaces_;
   MockMessageHelper& mock_message_helper_;
 };
 
@@ -133,6 +157,251 @@ TEST_F(AddSubMenuRequestTest, OnEvent_UI_UNSUPPORTED_RESOURCE) {
   Mock::VerifyAndClearExpectations(&mock_message_helper_);
 }
 
+TEST_F(AddSubMenuRequestTest, OnEvent_SUCCESS) {
+  MessageSharedPtr event_msg(CreateMessage(smart_objects::SmartType_Map));
+  (*event_msg)[am::strings::params][am::hmi_response::code] =
+      mobile_apis::Result::SUCCESS;
+  (*event_msg)[am::strings::msg_params] = 0;
+
+  Event event(hmi_apis::FunctionID::UI_AddSubMenu);
+  event.set_smart_object(*event_msg);
+  AddSubMenuPtr command(CreateCommand<AddSubMenuRequest>(command_msg_));
+  EXPECT_CALL(app_mngr_, application(kConnectionKey)).WillOnce(Return(app));
+
+  EXPECT_CALL(mock_message_helper_,
+              HMIToMobileResult(hmi_apis::Common_Result::SUCCESS))
+      .WillOnce(Return(mobile_apis::Result::SUCCESS));
+
+  MessageSharedPtr result_msg(
+      CatchMobileCommandResult(CallOnEvent(*command, event)));
+  const mobile_apis::Result::eType received_result =
+      static_cast<mobile_apis::Result::eType>(
+          (*result_msg)[am::strings::msg_params][am::strings::result_code]
+              .asInt());
+  EXPECT_EQ(mobile_apis::Result::SUCCESS, received_result);
+}
+
+TEST_F(AddSubMenuRequestTest,
+       OnEvent_SubMenuWithIcon_NotExistsInFolder_ExpectInfo) {
+  // Message will be sent on hmi with icon that not exists in folder
+  (*command_msg_)[am::strings::msg_params][am::strings::sub_menu_icon]
+                 [am::strings::value] = "icon.png";
+
+  MessageSharedPtr event_msg(CreateMessage(smart_objects::SmartType_Map));
+  (*event_msg)[am::strings::params][am::hmi_response::code] =
+      mobile_apis::Result::WARNINGS;
+  (*event_msg)[am::strings::msg_params] = 0;
+
+  Event event(hmi_apis::FunctionID::UI_AddSubMenu);
+  event.set_smart_object(*event_msg);
+
+  AddSubMenuPtr command(CreateCommand<AddSubMenuRequest>(command_msg_));
+
+  EXPECT_CALL(app_mngr_, application(kConnectionKey)).WillOnce(Return(app));
+
+  EXPECT_CALL(app_mngr_, get_settings())
+      .WillOnce(ReturnRef(app_mngr_settings_));
+
+  const std::string file_storage = "test_storage";
+  EXPECT_CALL(app_mngr_settings_, app_storage_folder())
+      .WillOnce(ReturnRef(file_storage));
+
+  EXPECT_CALL(mock_message_helper_,
+              HMIToMobileResult(hmi_apis::Common_Result::WARNINGS))
+      .WillOnce(Return(mobile_apis::Result::WARNINGS));
+
+  MessageSharedPtr result_msg(
+      CatchMobileCommandResult(CallOnEvent(*command, event)));
+  const mobile_apis::Result::eType received_result =
+      static_cast<mobile_apis::Result::eType>(
+          (*result_msg)[am::strings::msg_params][am::strings::result_code]
+              .asInt());
+
+  EXPECT_EQ(mobile_apis::Result::WARNINGS, received_result);
+  const std::string received_info =
+      (*result_msg)[am::strings::msg_params][am::strings::info].asString();
+  const std::string expected_info = "Reference image(s) not found";
+  EXPECT_EQ(expected_info, received_info);
+}
+
+TEST_F(AddSubMenuRequestTest, Run_ApplicationIsNotRegistered_UNSUCCESS) {
+  EXPECT_CALL(app_mngr_, application(_))
+      .WillOnce(Return(ApplicationSharedPtr()));
+
+  AddSubMenuPtr command(CreateCommand<AddSubMenuRequest>());
+  MessageSharedPtr result_msg(CatchMobileCommandResult(CallRun(*command)));
+  const mobile_apis::Result::eType received_result =
+      static_cast<mobile_apis::Result::eType>(
+          (*result_msg)[am::strings::msg_params][am::strings::result_code]
+              .asInt());
+  EXPECT_EQ(mobile_apis::Result::APPLICATION_NOT_REGISTERED, received_result);
+}
+
+TEST_F(AddSubMenuRequestTest, Run_InvalidSubMenuId_UNSUCCESS) {
+  MessageSharedPtr dummy_sub_menu(CreateMessage(smart_objects::SmartType_Null));
+  EXPECT_CALL(app_mngr_, application(kConnectionKey)).WillOnce(Return(app));
+  EXPECT_CALL(*app, FindSubMenu(kMenuId))
+      .WillOnce(Return(dummy_sub_menu.get()));
+
+  AddSubMenuPtr command(CreateCommand<AddSubMenuRequest>(command_msg_));
+  MessageSharedPtr result_msg(CatchMobileCommandResult(CallRun(*command)));
+  const mobile_apis::Result::eType received_result =
+      static_cast<mobile_apis::Result::eType>(
+          (*result_msg)[am::strings::msg_params][am::strings::result_code]
+              .asInt());
+  EXPECT_EQ(mobile_apis::Result::INVALID_ID, received_result);
+}
+
+TEST_F(AddSubMenuRequestTest, Run_DuplicatedSubMenuName_UNSUCCESS) {
+  AddSubMenuPtr command(CreateCommand<AddSubMenuRequest>(command_msg_));
+
+  EXPECT_CALL(app_mngr_, application(kConnectionKey)).WillOnce(Return(app));
+  EXPECT_CALL(*app, FindSubMenu(kMenuId)).WillOnce(ReturnNull());
+  EXPECT_CALL(*app, IsSubMenuNameAlreadyExist(_)).WillOnce(Return(true));
+
+  MessageSharedPtr result_msg(CatchMobileCommandResult(CallRun(*command)));
+  const mobile_apis::Result::eType received_result =
+      static_cast<mobile_apis::Result::eType>(
+          (*result_msg)[am::strings::msg_params][am::strings::result_code]
+              .asInt());
+  EXPECT_EQ(mobile_apis::Result::DUPLICATE_NAME, received_result);
+}
+
+TEST_F(AddSubMenuRequestTest, Run_NotValidSubMenuName_UNSUCCESS) {
+  // Not valid sub
+  (*command_msg_)[am::strings::msg_params][am::strings::menu_name] = "\t\n";
+  AddSubMenuPtr command(CreateCommand<AddSubMenuRequest>(command_msg_));
+  EXPECT_CALL(app_mngr_, application(kConnectionKey)).WillOnce(Return(app));
+  EXPECT_CALL(*app, FindSubMenu(kMenuId)).WillOnce(ReturnNull());
+
+  MessageSharedPtr result_msg(CatchMobileCommandResult(CallRun(*command)));
+  const mobile_apis::Result::eType received_result =
+      static_cast<mobile_apis::Result::eType>(
+          (*result_msg)[am::strings::msg_params][am::strings::result_code]
+              .asInt());
+  EXPECT_EQ(mobile_apis::Result::INVALID_DATA, received_result);
+}
+
+TEST_F(AddSubMenuRequestTest, Run_SUCCESS) {
+  (*command_msg_)[am::strings::msg_params][am::strings::menu_name] =
+      "valid_sub_menu_name";
+  (*command_msg_)[am::strings::msg_params][am::strings::position] =
+      "test_position";
+  EXPECT_CALL(app_mngr_, application(kConnectionKey)).WillOnce(Return(app));
+  EXPECT_CALL(*app, FindSubMenu(kMenuId)).WillOnce(ReturnNull());
+
+  EXPECT_CALL(mock_message_helper_,
+              HMIToMobileResult(hmi_apis::Common_Result::SUCCESS))
+      .WillOnce(Return(mobile_apis::Result::SUCCESS));
+  AddSubMenuPtr command(CreateCommand<AddSubMenuRequest>(command_msg_));
+  MessageSharedPtr result_msg(CatchHMICommandResult(CallRun(*command)));
+  const hmi_apis::FunctionID::eType received_result =
+      static_cast<hmi_apis::FunctionID::eType>(
+          (*result_msg)[am::strings::params][am::strings::function_id].asInt());
+  EXPECT_EQ(hmi_apis::FunctionID::UI_AddSubMenu, received_result);
+}
+
+TEST_F(AddSubMenuRequestTest, Run_MenuIconCorrectName_SUCCESS) {
+  (*command_msg_)[am::strings::msg_params][am::strings::menu_name] =
+      "valid_sub_menu_name";
+  (*command_msg_)[am::strings::msg_params][am::strings::position] =
+      "test_position";
+  (*command_msg_)[am::strings::msg_params][am::strings::sub_menu_icon]
+                 [am::strings::value] = "icon.png";
+  (*command_msg_)[am::strings::msg_params][am::strings::sub_menu_icon]
+                 [am::strings::type] = "DYNAMIC";
+
+  EXPECT_CALL(mock_message_helper_,
+              HMIToMobileResult(hmi_apis::Common_Result::SUCCESS))
+      .WillOnce(Return(mobile_apis::Result::SUCCESS));
+  AddSubMenuPtr command(CreateCommand<AddSubMenuRequest>(command_msg_));
+  EXPECT_CALL(app_mngr_, application(kConnectionKey)).WillOnce(Return(app));
+  EXPECT_CALL(*app, FindSubMenu(kMenuId)).WillOnce(ReturnNull());
+
+  EXPECT_CALL(mock_message_helper_,
+              HMIToMobileResult(hmi_apis::Common_Result::SUCCESS))
+      .WillOnce(Return(mobile_apis::Result::SUCCESS));
+
+  MessageSharedPtr result_msg(CatchHMICommandResult(CallRun(*command)));
+  const hmi_apis::FunctionID::eType received_result =
+      static_cast<hmi_apis::FunctionID::eType>(
+          (*result_msg)[am::strings::params][am::strings::function_id].asInt());
+  EXPECT_EQ(hmi_apis::FunctionID::UI_AddSubMenu, received_result);
+
+  EXPECT_EQ("icon.png",
+            (*result_msg)[am::strings::msg_params][am::strings::sub_menu_icon]
+                         [am::strings::value].asString());
+}
+
+TEST_F(AddSubMenuRequestTest, Run_MenuIconNewLineChar_SendWithoutIcon) {
+  (*command_msg_)[am::strings::msg_params][am::strings::menu_name] =
+      "valid_sub_menu_name";
+  (*command_msg_)[am::strings::msg_params][am::strings::sub_menu_icon]
+                 [am::strings::value] = "ico\nn.png";
+
+  EXPECT_CALL(app_mngr_, application(kConnectionKey)).WillOnce(Return(app));
+  EXPECT_CALL(*app, FindSubMenu(kMenuId)).WillOnce(ReturnNull());
+
+  EXPECT_CALL(mock_message_helper_,
+              HMIToMobileResult(hmi_apis::Common_Result::SUCCESS))
+      .WillOnce(Return(mobile_apis::Result::SUCCESS));
+  AddSubMenuPtr command(CreateCommand<AddSubMenuRequest>(command_msg_));
+  MessageSharedPtr result_msg(CatchHMICommandResult(CallRun(*command)));
+  const hmi_apis::FunctionID::eType received_result =
+      static_cast<hmi_apis::FunctionID::eType>(
+          (*result_msg)[am::strings::params][am::strings::function_id].asInt());
+  EXPECT_EQ(hmi_apis::FunctionID::UI_AddSubMenu, received_result);
+
+  EXPECT_FALSE((*result_msg)[am::strings::msg_params].keyExists(
+      am::strings::sub_menu_icon));
+}
+
+TEST_F(AddSubMenuRequestTest, Run_MenuIconTabChar_SendWithoutIcon) {
+  (*command_msg_)[am::strings::msg_params][am::strings::menu_name] =
+      "valid_sub_menu_name";
+  (*command_msg_)[am::strings::msg_params][am::strings::sub_menu_icon]
+                 [am::strings::value] = "ico\tn.png";
+
+  EXPECT_CALL(app_mngr_, application(kConnectionKey)).WillOnce(Return(app));
+  EXPECT_CALL(*app, FindSubMenu(kMenuId)).WillOnce(ReturnNull());
+  EXPECT_CALL(mock_message_helper_,
+              HMIToMobileResult(hmi_apis::Common_Result::SUCCESS))
+      .WillOnce(Return(mobile_apis::Result::SUCCESS));
+
+  AddSubMenuPtr command(CreateCommand<AddSubMenuRequest>(command_msg_));
+  MessageSharedPtr result_msg(CatchHMICommandResult(CallRun(*command)));
+  const hmi_apis::FunctionID::eType received_result =
+      static_cast<hmi_apis::FunctionID::eType>(
+          (*result_msg)[am::strings::params][am::strings::function_id].asInt());
+  EXPECT_EQ(hmi_apis::FunctionID::UI_AddSubMenu, received_result);
+
+  EXPECT_FALSE((*result_msg)[am::strings::msg_params].keyExists(
+      am::strings::sub_menu_icon));
+}
+
+TEST_F(AddSubMenuRequestTest, Run_MenuIconWhiteSpace_SendWithoutIcon) {
+  (*command_msg_)[am::strings::msg_params][am::strings::menu_name] =
+      "valid_sub_menu_name";
+  (*command_msg_)[am::strings::msg_params][am::strings::sub_menu_icon]
+                 [am::strings::value] = "ico n.png";
+
+  EXPECT_CALL(app_mngr_, application(kConnectionKey)).WillOnce(Return(app));
+  EXPECT_CALL(*app, FindSubMenu(kMenuId)).WillOnce(ReturnNull());
+  EXPECT_CALL(mock_message_helper_,
+              HMIToMobileResult(hmi_apis::Common_Result::SUCCESS))
+      .WillOnce(Return(mobile_apis::Result::SUCCESS));
+
+  AddSubMenuPtr command(CreateCommand<AddSubMenuRequest>(command_msg_));
+  MessageSharedPtr result_msg(CatchHMICommandResult(CallRun(*command)));
+  const hmi_apis::FunctionID::eType received_result =
+      static_cast<hmi_apis::FunctionID::eType>(
+          (*result_msg)[am::strings::params][am::strings::function_id].asInt());
+  EXPECT_EQ(hmi_apis::FunctionID::UI_AddSubMenu, received_result);
+
+  EXPECT_FALSE((*result_msg)[am::strings::msg_params].keyExists(
+      am::strings::sub_menu_icon));
+}
+
 }  // namespace add_sub_menu_request
 }  // namespace mobile_commands_test
 }  // namespace commands_test
diff --git a/src/components/application_manager/test/include/application_manager/resumption_data_test.h b/src/components/application_manager/test/include/application_manager/resumption_data_test.h
index 436c8c165e..3a67f8321a 100644
--- a/src/components/application_manager/test/include/application_manager/resumption_data_test.h
+++ b/src/components/application_manager/test/include/application_manager/resumption_data_test.h
@@ -68,7 +68,8 @@ class ResumptionDataTest : public ::testing::Test {
       , kCountOfSubmenues_(3u)
       , kCountOfFiles_(8u)
       , kCountOfVrhelptitle_(2u)
-      , kMacAddress_("12345") {}
+      , kMacAddress_("12345")
+      , kSubmenuStartId_(10u) {}
   // Check structure in saved application
   void CheckSavedApp(sm::SmartObject& saved_data);
   // Set data for resumption
@@ -130,6 +131,7 @@ class ResumptionDataTest : public ::testing::Test {
   const size_t kCountOfFiles_;
   const size_t kCountOfVrhelptitle_;
   const std::string kMacAddress_;
+  const size_t kSubmenuStartId_;
 
   am::CommandsMap test_commands_map;
   am::SubMenuMap test_submenu_map;
diff --git a/src/components/application_manager/test/resumption/resumption_data_db_test.cc b/src/components/application_manager/test/resumption/resumption_data_db_test.cc
index aa4db59eac..294f0b60d6 100644
--- a/src/components/application_manager/test/resumption/resumption_data_db_test.cc
+++ b/src/components/application_manager/test/resumption/resumption_data_db_test.cc
@@ -346,7 +346,7 @@ void ResumptionDataDBTest::CheckCharacters(int64_t global_properties_key) {
 }
 
 void ResumptionDataDBTest::CheckSubmenuData() {
-  utils::dbms::SQLQuery select_submenu(test_db());
+  ::utils::dbms::SQLQuery select_submenu(test_db());
 
   EXPECT_TRUE(select_submenu.Prepare(kSelectCountSubMenu));
   BindId(select_submenu);
@@ -357,13 +357,23 @@ void ResumptionDataDBTest::CheckSubmenuData() {
   BindId(select_submenu);
   int i = 10;
   while (select_submenu.Next()) {
-    uint32_t test_id = (*test_submenu_map[i])[am::strings::menu_id].asUInt();
-    std::string name =
+    const uint32_t test_id =
+        (*test_submenu_map[i])[am::strings::menu_id].asUInt();
+    const std::string name =
         (*test_submenu_map[i])[am::strings::menu_name].asString();
-    int position = (*test_submenu_map[i])[am::strings::position].asInt();
+
+    const int position = (*test_submenu_map[i])[am::strings::position].asInt();
+    const std::string image_value =
+        (*test_submenu_map[i])[am::strings::sub_menu_icon][am::strings::value]
+            .asString();
+    const int image_type =
+        (*test_submenu_map[i])[am::strings::sub_menu_icon]
+                              [am::strings::image_type].asInt();
     EXPECT_EQ(test_id, select_submenu.GetUInteger(0));
     EXPECT_EQ(name, select_submenu.GetString(1));
     EXPECT_EQ(position, select_submenu.GetInteger(2));
+    EXPECT_EQ(image_value, select_submenu.GetString(3));
+    EXPECT_EQ(image_type, select_submenu.GetInteger(4));
     i++;
   }
 }
diff --git a/src/components/application_manager/test/resumption/resumption_data_test.cc b/src/components/application_manager/test/resumption/resumption_data_test.cc
index 79397f5175..80ab694bd2 100644
--- a/src/components/application_manager/test/resumption/resumption_data_test.cc
+++ b/src/components/application_manager/test/resumption/resumption_data_test.cc
@@ -122,13 +122,29 @@ void ResumptionDataTest::CheckCommands(sm::SmartObject& res_list) {
 void ResumptionDataTest::CheckSubmenues(sm::SmartObject& res_list) {
   for (uint32_t i = 0; i < kCountOfSubmenues_; ++i) {
     uint32_t test_id =
-        (*test_submenu_map[i + 10])[am::strings::menu_id].asUInt();
+        (*test_submenu_map[i + kSubmenuStartId_])[am::strings::menu_id]
+            .asUInt();
     std::string name =
-        (*test_submenu_map[i + 10])[am::strings::menu_name].asString();
-    int position = (*test_submenu_map[i + 10])[am::strings::position].asInt();
+        (*test_submenu_map[i + kSubmenuStartId_])[am::strings::menu_name]
+            .asString();
+    int position =
+        (*test_submenu_map[i + kSubmenuStartId_])[am::strings::position]
+            .asInt();
+    std::string icon_name =
+        (*test_submenu_map[i + kSubmenuStartId_])
+            [am::strings::sub_menu_icon][am::strings::value].asString();
+    int icon_type =
+        (*test_submenu_map[i + kSubmenuStartId_])
+            [am::strings::sub_menu_icon][am::strings::image_type].asInt();
     EXPECT_EQ(position, res_list[i][am::strings::position].asInt());
     EXPECT_EQ(test_id, res_list[i][am::strings::menu_id].asUInt());
     EXPECT_EQ(name, res_list[i][am::strings::menu_name].asString());
+    EXPECT_EQ(
+        icon_name,
+        res_list[i][am::strings::sub_menu_icon][am::strings::value].asString());
+    EXPECT_EQ(icon_type,
+              res_list[i][am::strings::sub_menu_icon][am::strings::image_type]
+                  .asInt());
   }
 }
 
@@ -456,17 +472,22 @@ void ResumptionDataTest::SetCommands() {
 }
 
 void ResumptionDataTest::SetSubmenues() {
-  sm::SmartObject sm_comm;
-  for (uint32_t i = 10; i < kCountOfSubmenues_ + 10; ++i) {
+  sm::SmartObject so_submenu;
+  for (size_t i = kSubmenuStartId_; i < kCountOfSubmenues_ + kSubmenuStartId_;
+       ++i) {
     char numb[12];
-    std::snprintf(numb, 12, "%d", i);
-    sm_comm[am::strings::menu_id] = i;
-    sm_comm[am::strings::position] = i;
-    sm_comm[am::strings::menu_name] = "SubMenu" + std::string(numb);
-    test_submenu_map[i] = new sm::SmartObject(sm_comm);
+    snprintf(numb, 12, "%lu", i);
+    std::string numb_id(numb);
+    so_submenu[am::strings::menu_id] = i;
+    so_submenu[am::strings::position] = i;
+    so_submenu[am::strings::menu_name] = "SubMenu" + numb_id;
+    so_submenu[am::strings::sub_menu_icon][am::strings::value] =
+        "submenuicon" + numb_id;
+    so_submenu[am::strings::sub_menu_icon][am::strings::type] =
+        ImageType::STATIC;
+    test_submenu_map[i] = new sm::SmartObject(so_submenu);
   }
 }
-
 void ResumptionDataTest::SetChoiceSet() {
   sm::SmartObject choice_vector;
   sm::SmartObject choice;
diff --git a/src/components/application_manager/test/resumption_sql_queries_test.cc b/src/components/application_manager/test/resumption_sql_queries_test.cc
index 08fa0a3eb5..adc9c4e87d 100644
--- a/src/components/application_manager/test/resumption_sql_queries_test.cc
+++ b/src/components/application_manager/test/resumption_sql_queries_test.cc
@@ -111,6 +111,7 @@ class ResumptionSqlQueriesTest : public ::testing::Test {
   static const int ign_off_count2;
   static const int timeStamp;
   static const int timeStamp2;
+  static const int image_key;
 
   static void SetUpTestCase() {
     db_ = new SQLDatabase();
@@ -229,7 +230,8 @@ class ResumptionSqlQueriesTest : public ::testing::Test {
   SQLQuery& FillSubMenuTable(SQLQuery& query,
                              const int menuID,
                              const string& menuName,
-                             const int position);
+                             const int position,
+                             const int64_t image_id);
 
   SQLQuery& FillApplicationSubMenuArrayTable(SQLQuery& query,
                                              const int app_key,
@@ -351,6 +353,7 @@ const int ResumptionSqlQueriesTest::ign_off_count = 3;
 const int ResumptionSqlQueriesTest::ign_off_count2 = 4;
 const int ResumptionSqlQueriesTest::timeStamp = 2015;
 const int ResumptionSqlQueriesTest::timeStamp2 = 2016;
+const int ResumptionSqlQueriesTest::image_key = 4;
 
 void ResumptionSqlQueriesTest::CheckDeleteQuery(const string& count_query,
                                                 const string& query_to_check,
@@ -709,11 +712,13 @@ SQLQuery& ResumptionSqlQueriesTest::FillFileTable(SQLQuery& query,
 SQLQuery& ResumptionSqlQueriesTest::FillSubMenuTable(SQLQuery& query,
                                                      const int menuID,
                                                      const string& menuName,
-                                                     const int position) {
+                                                     const int position,
+                                                     const int64_t image_id) {
   EXPECT_TRUE(query.Prepare(kInsertToSubMenu));
   query.Bind(0, menuID);
   query.Bind(1, menuName);
   query.Bind(2, position);
+  query.Bind(3, image_id);
   EXPECT_TRUE(query.Exec());
   return query;
 }
@@ -1341,7 +1346,8 @@ TEST_F(ResumptionSqlQueriesTest, kDeleteSubMenu_ExpectDataDeleted) {
                              device_id,
                              key).LastInsertId();
   int64_t submenu_key =
-      FillSubMenuTable(temp_query, 1, "tst_menuName", 2).LastInsertId();
+      FillSubMenuTable(temp_query, 1, "tst_menuName", 2, image_key)
+          .LastInsertId();
 
   FillApplicationSubMenuArrayTable(temp_query, key, submenu_key);
   // Check
@@ -1373,7 +1379,8 @@ TEST_F(ResumptionSqlQueriesTest,
                              key).LastInsertId();
 
   int64_t submenu_key =
-      FillSubMenuTable(temp_query, 1, "tst_menuName", 2).LastInsertId();
+      FillSubMenuTable(temp_query, 1, "tst_menuName", 2, image_key)
+          .LastInsertId();
 
   FillApplicationSubMenuArrayTable(temp_query, key, submenu_key);
   // Check
@@ -2107,7 +2114,7 @@ TEST_F(ResumptionSqlQueriesTest,
 TEST_F(ResumptionSqlQueriesTest, kInsertToSubMenu_ExpectDataInserted) {
   // Arrange
   SQLQuery temp_query(db());
-  FillSubMenuTable(temp_query, 1, "tst_menu", 3);
+  FillSubMenuTable(temp_query, 1, "tst_menu", 3, image_key);
   // Checks
   const std::string select_count_subMenu = "SELECT COUNT(*) FROM subMenu;";
   CheckSelectQuery(select_count_subMenu, 1, 0);
@@ -2541,8 +2548,9 @@ TEST_F(ResumptionSqlQueriesTest, kSelectCountSubMenu_ExpectDataCorrect) {
                                          app_id1,
                                          device_id,
                                          9).LastInsertId();
+  int64_t key1 = FillImageTable(temp_query, 1, test_image).LastInsertId();
   int64_t submenu_key =
-      FillSubMenuTable(temp_query, 1, "menu_name", 1).LastInsertId();
+      FillSubMenuTable(temp_query, 1, "menu_name", 1, key1).LastInsertId();
   FillApplicationSubMenuArrayTable(temp_query, app_key, submenu_key);
   ValToPosPair p1(0, app_id1);
   ValToPosPair p2(1, device_id);
@@ -2565,8 +2573,9 @@ TEST_F(ResumptionSqlQueriesTest, kSelectSubMenu_ExpectDataCorrect) {
                                          app_id1,
                                          device_id,
                                          9).LastInsertId();
+  int64_t key1 = FillImageTable(temp_query, 1, test_image).LastInsertId();
   int64_t submenu_key =
-      FillSubMenuTable(temp_query, 1, "menu_name", 1).LastInsertId();
+      FillSubMenuTable(temp_query, 1, "menu_name", 1, key1).LastInsertId();
 
   FillApplicationSubMenuArrayTable(temp_query, app_key, submenu_key);
   ValToPosPair p1(0, app_id1);