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