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
  52   table[1] = strdup("apppath");
  53   if (table[1] == nullptr) {
  54     goto out;
  55   }
  56
  57   table[2] = strdup("arg");
  58   if (table[2] == nullptr) {
  59     goto out;
  60   }
  61
  62   table[3] = strdup("122232");
  63   if (table[3] == nullptr) {
  64     goto out;
  65   }
  66
  67   table[4] = strdup("instance_id");
  68   if (table[4] == nullptr) {
  69     goto out;
  70   }
  71
  72   table[5] = strdup("instance_name");
  73   if (table[5] == nullptr) {
  74     goto out;
  75   }
  76
  77   table[6] = strdup("icon");
  78   if (table[6] == nullptr) {
  79     goto out;
  80   }
  81
  82   table[7] = strdup("uri");
  83   if (table[7] == nullptr) {
  84     goto out;
  85   }
  86
  87   table[8] = strdup("image");
  88   if (table[8] == nullptr) {
  89     goto out;
  90   }
  91
  92   table[9] = strdup("compid");
  93   if (table[9] == nullptr) {
  94     goto out;
  95   }
  96
  97   return table;
  98
  99 out:
 100   for (int i = 0; i < 10; i++) {
 101     if (table[i])
 102       free(table[i]);
 103   }
 104
 105   return nullptr;
 106 }
 107
 108 class ManagerMocks : public ::testing::NiceMock<AulMock>,
 109               public ::testing::NiceMock<PkgmgrInfoMock>,
 110               public ::testing::NiceMock<SqlMock> {};
 111
 112 class RuaManagerTest : public TestFixture {
 113  public:
 114   RuaManagerTest() : TestFixture(std::make_unique<ManagerMocks>()) {}
 115   virtual ~RuaManagerTest() {}
 116
 117   virtual void SetUp() {
 118     table_ = __create_table();
 119     if (table_ == nullptr)
 120       return;
 121
 122     temp_ = (void*)malloc(1);
 123     if (temp_ == nullptr)
 124       return;
 125
 126     EXPECT_CALL(GetMock<SqlMock>(),
 127         sqlite3_open_v2(_, _, _, _)).WillRepeatedly(Return(0));
 128     EXPECT_CALL(GetMock<SqlMock>(),
 129         sqlite3_close_v2(_)).WillRepeatedly(Return(0));
 130     EXPECT_CALL(GetMock<SqlMock>(),
 131         sqlite3_free_table(_));
 132     EXPECT_CALL(GetMock<SqlMock>(),
 133         sqlite3_busy_handler(_, _, _)).WillRepeatedly(Return(0));
 134     EXPECT_CALL(GetMock<SqlMock>(),
 135         sqlite3_get_table(_, _, _, _, _, _)).
 136         WillOnce(DoAll(SetArgPointee<2>(table_),
 137                       SetArgPointee<3>(1),
 138                       SetArgPointee<4>(0), (Return(0))));
 139     EXPECT_CALL(GetMock<PkgmgrInfoMock>(),
 140         pkgmgrinfo_appinfo_get_appinfo(_, _)).
 141         WillOnce(DoAll(SetArgPointee<1>(temp_),Return(0)));
 142     EXPECT_CALL(GetMock<AulMock>(),
 143         aul_comp_info_create(_, _)).
 144         WillOnce(DoAll(SetArgPointee<1>(temp_),Return(0)));
 145     EXPECT_CALL(GetMock<AulMock>(),
 146         aul_comp_info_destroy(_)).
 147         WillRepeatedly(Return(0));
 148     EXPECT_CALL(GetMock<PkgmgrInfoMock>(),
 149         pkgmgrinfo_appinfo_destroy_appinfo(_)).
 150         WillRepeatedly(Return(0));
 151     EXPECT_CALL(GetMock<PkgmgrInfoMock>(),
 152         pkgmgrinfo_appinfo_clone_appinfo(_, _)).
 153         WillOnce(DoAll(SetArgPointee<1>(temp_),Return(0)));
 154     EXPECT_CALL(GetMock<AulMock>(),
 155         aul_comp_info_clone(_, _)).
 156         WillOnce(DoAll(SetArgPointee<1>(temp_),Return(0)));
 157
 158     rua_manager_foreach_rua_info(__rua_info_cb, &info_);
 159   }
 160
 161   virtual void TearDown() {
 162     if (table_) {
 163       for (int i = 0; i < 10; i++)
 164         free(table_[i]);
 165       free(table_);
 166     }
 167     if (temp_)
 168       free(temp_);
 169
 170     rua_info_destroy(info_);
 171   }
 172
 173  public:
 174   rua_info_h info_ = nullptr;
 175
 176  private:
 177   char** table_ = nullptr;
 178   void* temp_ = nullptr;
 179 };
 180
 181 TEST_F(RuaManagerTest, rua_manager_delete_rua_info) {
 182   EXPECT_CALL(GetMock<AulMock>(),
 183     aul_delete_rua_history_for_uid(_, _)).
 184         WillOnce(Return(0));
 185
 186   int ret = rua_manager_delete_rua_info(info_);
 187   EXPECT_EQ(ret, 0);
 188 }
 189
 190 TEST_F(RuaManagerTest, rua_manager_delete_all_rua_info) {
 191   EXPECT_CALL(GetMock<AulMock>(),
 192     aul_delete_rua_history_for_uid(_, _)).
 193         WillOnce(Return(0));
 194
 195   int ret = rua_manager_delete_all_rua_info();
 196   EXPECT_EQ(ret, 0);
 197 }
 198
 199 TEST_F(RuaManagerTest, rua_manager_get_app_control_from_rua_info_N) {
 200   app_control_h ac;
 201
 202   int ret = rua_manager_get_app_control_from_rua_info(info_, &ac);
 203   EXPECT_NE(ret, 0);
 204 }
 205
 206 TEST_F(RuaManagerTest, rua_manager_get_rua_context_from_rua_info) {
 207   rua_context_h ctx;
 208
 209   int ret = rua_manager_get_rua_context_from_rua_info(info_, &ctx);
 210   EXPECT_EQ(ret, 0);
 211
 212   ret = rua_context_destroy(ctx);
 213   EXPECT_EQ(ret, 0);
 214 }
 215
 216
 217 TEST_F(RuaManagerTest, rua_manager_is_running_N) {
 218   rua_context_h ctx;
 219   bool running;
 220
 221   int ret = rua_manager_get_rua_context_from_rua_info(info_, &ctx);
 222   EXPECT_EQ(ret, 0);
 223
 224   ret = rua_manager_is_running(ctx, &running);
 225   EXPECT_NE(ret, 0);
 226
 227   ret = rua_context_destroy(ctx);
 228   EXPECT_EQ(ret, 0);
 229 }
 230
 231 TEST_F(RuaManagerTest, rua_manager_resume_N) {
 232   rua_context_h ctx;
 233
 234   int ret = rua_manager_get_rua_context_from_rua_info(info_, &ctx);
 235   EXPECT_EQ(ret, 0);
 236
 237   ret = rua_manager_resume(ctx);
 238   EXPECT_NE(ret, 0);
 239
 240   ret = rua_context_destroy(ctx);
 241   EXPECT_EQ(ret, 0);
 242 }
 243
 244 TEST_F(RuaManagerTest, rua_manager_terminate_N) {
 245   rua_context_h ctx;
 246
 247   int ret = rua_manager_get_rua_context_from_rua_info(info_, &ctx);
 248   EXPECT_EQ(ret, 0);
 249
 250   ret = rua_manager_terminate(ctx);
 251   EXPECT_NE(ret, 0);
 252
 253   ret = rua_context_destroy(ctx);
 254   EXPECT_EQ(ret, 0);
 255 }
 256
 257 TEST_F(RuaManagerTest, rua_context_get_app_id) {
 258   rua_context_h ctx;
 259   char* appid;
 260
 261   int ret = rua_manager_get_rua_context_from_rua_info(info_, &ctx);
 262   EXPECT_EQ(ret, 0);
 263
 264   ret = rua_context_get_app_id(ctx, &appid);
 265   EXPECT_EQ(ret, 0);
 266   EXPECT_EQ(appid, std::string("pkgname"));
 267
 268   free(appid);
 269 }
 270
 271 TEST_F(RuaManagerTest, rua_context_get_instance_id) {
 272   rua_context_h ctx;
 273   char* instanceid;
 274
 275   int ret = rua_manager_get_rua_context_from_rua_info(info_, &ctx);
 276   EXPECT_EQ(ret, 0);
 277
 278   ret = rua_context_get_instance_id(ctx, &instanceid);
 279   EXPECT_EQ(ret, 0);
 280   EXPECT_EQ(instanceid, std::string("instance_id"));
 281
 282   free(instanceid);
 283 }
 284
 285 TEST_F(RuaManagerTest, rua_context_get_component_id) {
 286   rua_context_h ctx;
 287   char* compid;
 288
 289   int ret = rua_manager_get_rua_context_from_rua_info(info_, &ctx);
 290   EXPECT_EQ(ret, 0);
 291
 292   ret = rua_context_get_component_id(ctx, &compid);
 293   EXPECT_EQ(ret, 0);
 294   EXPECT_EQ(compid, std::string("compid"));
 295
 296   free(compid);
 297 }
 298
 299 TEST_F(RuaManagerTest, rua_info_get_app_id) {
 300   char* app_id;
 301
 302   int ret = rua_info_get_app_id(info_, &app_id);
 303   EXPECT_EQ(ret, 0);
 304   EXPECT_EQ(app_id, std::string("pkgname"));
 305
 306   free(app_id);
 307 }
 308
 309 TEST_F(RuaManagerTest, rua_info_get_app_path) {
 310   char* app_path;
 311
 312   int ret = rua_info_get_app_path(info_, &app_path);
 313   EXPECT_EQ(ret, 0);
 314   EXPECT_EQ(app_path, std::string("apppath"));
 315
 316   free(app_path);
 317 }
 318
 319 TEST_F(RuaManagerTest, rua_info_get_args) {
 320   char* args;
 321
 322   int ret = rua_info_get_args(info_, &args);
 323   EXPECT_EQ(ret, 0);
 324   EXPECT_EQ(args, std::string("arg"));
 325
 326   free(args);
 327 }
 328
 329 TEST_F(RuaManagerTest, rua_info_get_launch_time) {
 330   time_t launch_time;
 331
 332   int ret = rua_info_get_launch_time(info_, &launch_time);
 333   EXPECT_EQ(ret, 0);
 334   EXPECT_EQ(launch_time, 122232);
 335 }
 336
 337 TEST_F(RuaManagerTest, rua_info_get_instance_id) {
 338   char* instance_id;
 339
 340   int ret = rua_info_get_instance_id(info_, &instance_id);
 341   EXPECT_EQ(ret, 0);
 342   EXPECT_EQ(instance_id, std::string("instance_id"));
 343
 344   free(instance_id);
 345 }
 346
 347 TEST_F(RuaManagerTest, rua_info_get_instance_name) {
 348   char* instance_name;
 349
 350   int ret = rua_info_get_instance_name(info_, &instance_name);
 351   EXPECT_EQ(ret, 0);
 352   EXPECT_EQ(instance_name, std::string("instance_name"));
 353
 354   free(instance_name);
 355 }
 356
 357 TEST_F(RuaManagerTest, rua_info_get_icon) {
 358   char* icon;
 359
 360   int ret = rua_info_get_icon(info_, &icon);
 361   EXPECT_EQ(ret, 0);
 362   EXPECT_EQ(icon, std::string("icon"));
 363
 364   free(icon);
 365 }
 366
 367 TEST_F(RuaManagerTest, rua_info_get_uri) {
 368   char* uri;
 369
 370   int ret = rua_info_get_uri(info_, &uri);
 371   EXPECT_EQ(ret, 0);
 372   EXPECT_EQ(uri, std::string("uri"));
 373
 374   free(uri);
 375 }
 376
 377 TEST_F(RuaManagerTest, rua_info_get_image) {
 378   char* image;
 379
 380   int ret = rua_info_get_image(info_, &image);
 381   EXPECT_EQ(ret, 0);
 382   EXPECT_EQ(image, std::string("image"));
 383
 384   free(image);
 385 }
 386
 387 TEST_F(RuaManagerTest, rua_info_get_component_id) {
 388   char* comp_id;
 389
 390   int ret = rua_info_get_component_id(info_, &comp_id);
 391   EXPECT_EQ(ret, 0);
 392   EXPECT_EQ(comp_id, std::string("compid"));
 393
 394   free(comp_id);
 395 }
 396
 397 TEST_F(RuaManagerTest, rua_info_is_managed_by_task_manager) {
 398   EXPECT_CALL(GetMock<AulMock>(),
 399       aul_comp_info_is_taskmanage(_, _)).
 400           WillOnce(Return(0));
 401
 402   bool managed;
 403
 404   int ret = rua_info_is_managed_by_task_manager(info_, &managed);
 405   EXPECT_EQ(ret, 0);
 406 }
 407
 408 TEST_F(RuaManagerTest, rua_info_get_label) {
 409   EXPECT_CALL(GetMock<AulMock>(),
 410       aul_comp_info_get_label(_, _)).
 411           WillOnce(Return(0));
 412
 413   char* label;
 414
 415   int ret = rua_info_get_label(info_, &label);
 416   EXPECT_EQ(ret, 0);
 417 }