tests/unittest/rua_manager_unit_test.cc

   1 /*
   2  * Copyright (c) 2020 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <gtest/gtest.h>
  18
  19 #include <rua.h>
  20 #include <rua_manager.h>
  21
  22 #include <string>
  23 #include <vector>
  24 #include <memory>
  25
  26 #include "aul_mock.h"
  27 #include "sqlite3_mock.h"
  28 #include "pkgmgr_info_mock.h"
  29 #include "test_fixture.h"
  30
  31 using ::testing::_;
  32 using ::testing::DoAll;
  33 using ::testing::SetArgPointee;
  34 using ::testing::Return;
  35
  36 static bool __rua_info_cb(rua_info_h info, void* user_data) {
  37   if (user_data) {
  38     rua_info_h* cloned = (rua_info_h*)user_data;
  39     rua_info_clone(info, cloned);
  40   }
  41
  42   return false;
  43 }
  44
  45 static char** __create_table(void) {
  46   char** table = (char** )calloc(10, sizeof(char*));
  47   table[0] = strdup("pkgname");
  48   if (table[0] == nullptr)
  49     goto out;
  50
  51   table[1] = strdup("apppath");
  52   if (table[1] == nullptr)
  53     goto out;
  54
  55   table[2] = strdup("arg");
  56   if (table[2] == nullptr)
  57     goto out;
  58
  59   table[3] = strdup("122232");
  60   if (table[3] == nullptr)
  61     goto out;
  62
  63   table[4] = strdup("instance_id");
  64   if (table[4] == nullptr)
  65     goto out;
  66
  67   table[5] = strdup("instance_name");
  68   if (table[5] == nullptr)
  69     goto out;
  70
  71   table[6] = strdup("icon");
  72   if (table[6] == nullptr)
  73     goto out;
  74
  75   table[7] = strdup("uri");
  76   if (table[7] == nullptr)
  77     goto out;
  78
  79   table[8] = strdup("image");
  80   if (table[8] == nullptr)
  81     goto out;
  82
  83   table[9] = strdup("compid");
  84   if (table[9] == nullptr)
  85     goto out;
  86
  87   return table;
  88
  89 out:
  90   for (int i = 0; i < 10; i++) {
  91     if (table[i])
  92       free(table[i]);
  93   }
  94
  95   return nullptr;
  96 }
  97
  98 class ManagerMocks : public ::testing::NiceMock<AulMock>,
  99               public ::testing::NiceMock<PkgmgrInfoMock>,
 100               public ::testing::NiceMock<SqlMock> {};
 101
 102 class RuaManagerTest : public TestFixture {
 103  public:
 104   RuaManagerTest() : TestFixture(std::make_unique<ManagerMocks>()) {}
 105   virtual ~RuaManagerTest() {}
 106
 107   virtual void SetUp() {
 108     table_ = __create_table();
 109     if (table_ == nullptr)
 110       return;
 111
 112     temp_ = (void*)malloc(1);
 113     if (temp_ == nullptr)
 114       return;
 115
 116     EXPECT_CALL(GetMock<SqlMock>(),
 117         sqlite3_open_v2(_, _, _, _)).WillRepeatedly(Return(0));
 118     EXPECT_CALL(GetMock<SqlMock>(),
 119         sqlite3_close_v2(_)).WillRepeatedly(Return(0));
 120     EXPECT_CALL(GetMock<SqlMock>(),
 121         sqlite3_free_table(_));
 122     EXPECT_CALL(GetMock<SqlMock>(),
 123         sqlite3_busy_handler(_, _, _)).WillRepeatedly(Return(0));
 124     EXPECT_CALL(GetMock<SqlMock>(),
 125         sqlite3_get_table(_, _, _, _, _, _)).
 126         WillOnce(DoAll(SetArgPointee<2>(table_),
 127                       SetArgPointee<3>(1),
 128                       SetArgPointee<4>(0), (Return(0))));
 129     EXPECT_CALL(GetMock<PkgmgrInfoMock>(),
 130         pkgmgrinfo_appinfo_get_appinfo(_, _)).
 131         WillOnce(DoAll(SetArgPointee<1>(temp_),Return(0)));
 132     EXPECT_CALL(GetMock<AulMock>(),
 133         aul_comp_info_create(_, _)).
 134         WillOnce(DoAll(SetArgPointee<1>(temp_),Return(0)));
 135     EXPECT_CALL(GetMock<AulMock>(),
 136         aul_comp_info_destroy(_)).
 137         WillRepeatedly(Return(0));
 138     EXPECT_CALL(GetMock<PkgmgrInfoMock>(),
 139         pkgmgrinfo_appinfo_destroy_appinfo(_)).
 140         WillRepeatedly(Return(0));
 141     EXPECT_CALL(GetMock<PkgmgrInfoMock>(),
 142         pkgmgrinfo_appinfo_clone_appinfo(_, _)).
 143         WillOnce(DoAll(SetArgPointee<1>(temp_),Return(0)));
 144     EXPECT_CALL(GetMock<AulMock>(),
 145         aul_comp_info_clone(_, _)).
 146         WillOnce(DoAll(SetArgPointee<1>(temp_),Return(0)));
 147
 148     rua_manager_foreach_rua_info(__rua_info_cb, &info_);
 149   }
 150
 151   virtual void TearDown() {
 152     if (table_) {
 153       for (int i = 0; i < 10; i++)
 154         free(table_[i]);
 155       free(table_);
 156     }
 157     if (temp_)
 158       free(temp_);
 159
 160     rua_info_destroy(info_);
 161   }
 162
 163  public:
 164   rua_info_h info_ = nullptr;
 165
 166  private:
 167   char** table_ = nullptr;
 168   void* temp_ = nullptr;
 169 };
 170
 171 TEST_F(RuaManagerTest, rua_manager_delete_rua_info) {
 172   EXPECT_CALL(GetMock<AulMock>(),
 173     aul_delete_rua_history_for_uid(_, _)).
 174         WillOnce(Return(0));
 175
 176   int ret = rua_manager_delete_rua_info(info_);
 177   EXPECT_EQ(ret, 0);
 178 }
 179
 180 TEST_F(RuaManagerTest, rua_manager_delete_all_rua_info) {
 181   EXPECT_CALL(GetMock<AulMock>(),
 182     aul_delete_rua_history_for_uid(_, _)).
 183         WillOnce(Return(0));
 184
 185   int ret = rua_manager_delete_all_rua_info();
 186   EXPECT_EQ(ret, 0);
 187 }
 188
 189 TEST_F(RuaManagerTest, rua_manager_get_app_control_from_rua_info_N) {
 190   app_control_h ac;
 191
 192   int ret = rua_manager_get_app_control_from_rua_info(info_, &ac);
 193   EXPECT_NE(ret, 0);
 194 }
 195
 196 TEST_F(RuaManagerTest, rua_manager_get_rua_context_from_rua_info) {
 197   rua_context_h ctx;
 198
 199   int ret = rua_manager_get_rua_context_from_rua_info(info_, &ctx);
 200   EXPECT_EQ(ret, 0);
 201
 202   ret = rua_context_destroy(ctx);
 203   EXPECT_EQ(ret, 0);
 204 }
 205
 206
 207 TEST_F(RuaManagerTest, rua_manager_is_running_N) {
 208   rua_context_h ctx;
 209   bool running;
 210
 211   int ret = rua_manager_get_rua_context_from_rua_info(info_, &ctx);
 212   EXPECT_EQ(ret, 0);
 213
 214   ret = rua_manager_is_running(ctx, &running);
 215   EXPECT_NE(ret, 0);
 216
 217   ret = rua_context_destroy(ctx);
 218   EXPECT_EQ(ret, 0);
 219 }
 220
 221 TEST_F(RuaManagerTest, rua_manager_resume_N) {
 222   rua_context_h ctx;
 223
 224   int ret = rua_manager_get_rua_context_from_rua_info(info_, &ctx);
 225   EXPECT_EQ(ret, 0);
 226
 227   ret = rua_manager_resume(ctx);
 228   EXPECT_NE(ret, 0);
 229
 230   ret = rua_context_destroy(ctx);
 231   EXPECT_EQ(ret, 0);
 232 }
 233
 234 TEST_F(RuaManagerTest, rua_manager_terminate_N) {
 235   rua_context_h ctx;
 236
 237   int ret = rua_manager_get_rua_context_from_rua_info(info_, &ctx);
 238   EXPECT_EQ(ret, 0);
 239
 240   ret = rua_manager_terminate(ctx);
 241   EXPECT_NE(ret, 0);
 242
 243   ret = rua_context_destroy(ctx);
 244   EXPECT_EQ(ret, 0);
 245 }
 246
 247 TEST_F(RuaManagerTest, rua_context_get_app_id) {
 248   rua_context_h ctx;
 249   char* appid;
 250
 251   int ret = rua_manager_get_rua_context_from_rua_info(info_, &ctx);
 252   EXPECT_EQ(ret, 0);
 253
 254   ret = rua_context_get_app_id(ctx, &appid);
 255   EXPECT_EQ(ret, 0);
 256   EXPECT_EQ(appid, std::string("pkgname"));
 257
 258   free(appid);
 259 }
 260
 261 TEST_F(RuaManagerTest, rua_context_get_instance_id) {
 262   rua_context_h ctx;
 263   char* instanceid;
 264
 265   int ret = rua_manager_get_rua_context_from_rua_info(info_, &ctx);
 266   EXPECT_EQ(ret, 0);
 267
 268   ret = rua_context_get_instance_id(ctx, &instanceid);
 269   EXPECT_EQ(ret, 0);
 270   EXPECT_EQ(instanceid, std::string("instance_id"));
 271
 272   free(instanceid);
 273 }
 274
 275 TEST_F(RuaManagerTest, rua_context_get_component_id) {
 276   rua_context_h ctx;
 277   char* compid;
 278
 279   int ret = rua_manager_get_rua_context_from_rua_info(info_, &ctx);
 280   EXPECT_EQ(ret, 0);
 281
 282   ret = rua_context_get_component_id(ctx, &compid);
 283   EXPECT_EQ(ret, 0);
 284   EXPECT_EQ(compid, std::string("compid"));
 285
 286   free(compid);
 287 }
 288
 289 TEST_F(RuaManagerTest, rua_info_get_app_id) {
 290   char* app_id;
 291
 292   int ret = rua_info_get_app_id(info_, &app_id);
 293   EXPECT_EQ(ret, 0);
 294   EXPECT_EQ(app_id, std::string("pkgname"));
 295
 296   free(app_id);
 297 }
 298
 299 TEST_F(RuaManagerTest, rua_info_get_app_path) {
 300   char* app_path;
 301
 302   int ret = rua_info_get_app_path(info_, &app_path);
 303   EXPECT_EQ(ret, 0);
 304   EXPECT_EQ(app_path, std::string("apppath"));
 305
 306   free(app_path);
 307 }
 308
 309 TEST_F(RuaManagerTest, rua_info_get_args) {
 310   char* args;
 311
 312   int ret = rua_info_get_args(info_, &args);
 313   EXPECT_EQ(ret, 0);
 314   EXPECT_EQ(args, std::string("arg"));
 315
 316   free(args);
 317 }
 318
 319 TEST_F(RuaManagerTest, rua_info_get_launch_time) {
 320   time_t launch_time;
 321
 322   int ret = rua_info_get_launch_time(info_, &launch_time);
 323   EXPECT_EQ(ret, 0);
 324   EXPECT_EQ(launch_time, 122232);
 325 }
 326
 327 TEST_F(RuaManagerTest, rua_info_get_instance_id) {
 328   char* instance_id;
 329
 330   int ret = rua_info_get_instance_id(info_, &instance_id);
 331   EXPECT_EQ(ret, 0);
 332   EXPECT_EQ(instance_id, std::string("instance_id"));
 333
 334   free(instance_id);
 335 }
 336
 337 TEST_F(RuaManagerTest, rua_info_get_instance_name) {
 338   char* instance_name;
 339
 340   int ret = rua_info_get_instance_name(info_, &instance_name);
 341   EXPECT_EQ(ret, 0);
 342   EXPECT_EQ(instance_name, std::string("instance_name"));
 343
 344   free(instance_name);
 345 }
 346
 347 TEST_F(RuaManagerTest, rua_info_get_icon) {
 348   char* icon;
 349
 350   int ret = rua_info_get_icon(info_, &icon);
 351   EXPECT_EQ(ret, 0);
 352   EXPECT_EQ(icon, std::string("icon"));
 353
 354   free(icon);
 355 }
 356
 357 TEST_F(RuaManagerTest, rua_info_get_uri) {
 358   char* uri;
 359
 360   int ret = rua_info_get_uri(info_, &uri);
 361   EXPECT_EQ(ret, 0);
 362   EXPECT_EQ(uri, std::string("uri"));
 363
 364   free(uri);
 365 }
 366
 367 TEST_F(RuaManagerTest, rua_info_get_image) {
 368   char* image;
 369
 370   int ret = rua_info_get_image(info_, &image);
 371   EXPECT_EQ(ret, 0);
 372   EXPECT_EQ(image, std::string("image"));
 373
 374   free(image);
 375 }
 376
 377 TEST_F(RuaManagerTest, rua_info_get_component_id) {
 378   char* comp_id;
 379
 380   int ret = rua_info_get_component_id(info_, &comp_id);
 381   EXPECT_EQ(ret, 0);
 382   EXPECT_EQ(comp_id, std::string("compid"));
 383
 384   free(comp_id);
 385 }
 386
 387 TEST_F(RuaManagerTest, rua_info_is_managed_by_task_manager) {
 388   EXPECT_CALL(GetMock<AulMock>(),
 389       aul_comp_info_is_taskmanage(_, _)).
 390           WillOnce(Return(0));
 391
 392   bool managed;
 393
 394   int ret = rua_info_is_managed_by_task_manager(info_, &managed);
 395   EXPECT_EQ(ret, 0);
 396 }
 397
 398 TEST_F(RuaManagerTest, rua_info_get_label) {
 399   EXPECT_CALL(GetMock<AulMock>(),
 400       aul_comp_info_get_label(_, _)).
 401           WillOnce(Return(0));
 402
 403   char* label;
 404
 405   int ret = rua_info_get_label(info_, &label);
 406   EXPECT_EQ(ret, 0);
 407 }