unit-tests/lib/test_lib.cc

   1 /*
   2  * app2sd-unittest
   3  *
   4  * Copyright (c) 2020 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 #include <dlfcn.h>
  21 #include <gio/gio.h>
  22 #include <gmock/gmock.h>
  23 #include <tzplatform_config.h>
  24 #include <pkgmgr-info.h>
  25 #include "inc/app2ext_interface.h"
  26
  27 namespace {
  28
  29 static GVariant* __last_parameters;
  30 static gchar* __last_method_name;
  31
  32 extern "C" uid_t getuid(void) {
  33   return 1;
  34 }
  35
  36 extern "C" GDBusConnection* g_bus_get_sync(GBusType type,
  37     GCancellable* cancellable, GError** error) {
  38   gpointer dummy = g_object_new(G_TYPE_OBJECT, nullptr);
  39   return (GDBusConnection*)dummy;
  40 }
  41
  42 extern "C" GDBusProxy* g_dbus_proxy_new_sync(GDBusConnection* connection,
  43     GDBusProxyFlags flags, GDBusInterfaceInfo* info, const gchar* name,
  44     const gchar* object_path, const gchar* interface_name,
  45     GCancellable* cancellable, GError** error) {
  46   gpointer dummy = g_object_new(G_TYPE_OBJECT, nullptr);
  47   return (GDBusProxy*)dummy;
  48 }
  49
  50 extern "C" GVariant* g_dbus_proxy_call_sync(GDBusProxy* proxy,
  51     const gchar* method_name, GVariant* parameters, GDBusCallFlags flags,
  52     gint timeout_msec, GCancellable* cancellable, GError** error) {
  53   GVariant* gv = g_variant_new("(i)", 0);
  54
  55   if (parameters != nullptr) {
  56     if (__last_parameters)
  57         g_variant_unref(__last_parameters);
  58     __last_parameters = g_variant_ref(parameters);
  59   }
  60
  61   if (__last_method_name)
  62     g_free(__last_method_name);
  63
  64   __last_method_name = g_strdup(method_name);
  65   return gv;
  66 }
  67
  68 extern "C" const char* tzplatform_getenv(enum tzplatform_variable id) {
  69   return ".";
  70   //return "/home/abuild/rpmbuild/BUILD/app2sd-0.7.17/unit-tests";
  71 //  getcwd(__cwd, sizeof(__cwd));
  72
  73   //return const_cast<char*>(__cwd);
  74 }
  75
  76 extern "C" int pkgmgrinfo_pkginfo_get_usr_pkginfo(const char* pkgid, pkgmgrinfo_pkginfo_h handle) {
  77   return 0;
  78 }
  79
  80 extern "C" int pkgmgrinfo_pkginfo_get_installed_storage(pkgmgrinfo_pkginfo_h h, pkgmgrinfo_installed_storage* storage) {
  81   return 0;
  82 }
  83
  84 extern "C" int pkgmgrinfo_pkginfo_destroy_pkginfo(pkgmgrinfo_pkginfo_h h) {
  85   return 0;
  86 }
  87
  88 const ::testing::Environment* env = nullptr;
  89
  90 class App2extInterfaceTest : public ::testing::Test {
  91  protected:
  92   void SetUp() override {}
  93
  94   void TearDown() override {
  95     if (__last_parameters) {
  96       g_variant_unref(__last_parameters);
  97       __last_parameters = nullptr;
  98     }
  99     if (__last_method_name) {
 100       g_free(__last_method_name);
 101       __last_method_name = nullptr;
 102     }
 103   }
 104 };
 105
 106 TEST_F(App2extInterfaceTest, Init) {
 107   app2ext_handle* handle = app2ext_init(APP2EXT_INTERNAL_MEM);
 108   EXPECT_THAT(handle, testing::Eq(nullptr));
 109   handle = app2ext_init(APP2EXT_SD_CARD);
 110   ASSERT_TRUE(handle != nullptr);
 111   EXPECT_THAT(handle->type, testing::Eq(APP2EXT_SD_CARD));
 112   app2ext_deinit(handle);
 113 }
 114
 115 TEST_F(App2extInterfaceTest, EnableDisableExternalPkgs) {
 116   // wrong parameters
 117   int ret = app2ext_enable_external_pkg(nullptr);
 118   EXPECT_THAT(ret, testing::Eq(-1));
 119   ret = app2ext_disable_external_pkg(nullptr);
 120   EXPECT_THAT(ret, testing::Eq(-1));
 121
 122   // normal
 123   ret = app2ext_enable_external_pkg("not.exists.package");
 124   EXPECT_THAT(ret, testing::Eq(0));
 125   EXPECT_THAT(__last_method_name, testing::StrEq("OndemandSetupInit"));
 126   gchar* pkgid;
 127   gint uid;
 128   g_variant_get(__last_parameters, "(si)", &pkgid, &uid);
 129   EXPECT_THAT(pkgid, testing::StrEq("not.exists.package"));
 130   g_free(pkgid);
 131
 132   ret = app2ext_disable_external_pkg("not.exists.package");
 133   EXPECT_THAT(ret, testing::Eq(0));
 134   EXPECT_THAT(__last_method_name, testing::StrEq("OndemandSetupExit"));
 135   g_variant_get(__last_parameters, "(si)", &pkgid, &uid);
 136   EXPECT_THAT(pkgid, testing::StrEq("not.exists.package"));
 137   g_free(pkgid);
 138
 139   ret = app2ext_enable_all_external_pkgs();
 140   EXPECT_THAT(ret, testing::Eq(0));
 141   EXPECT_THAT(__last_method_name, testing::StrEq("EnableFullPkg"));
 142
 143   ret = app2ext_disable_all_external_pkgs();
 144   EXPECT_THAT(ret, testing::Eq(0));
 145   EXPECT_THAT(__last_method_name, testing::StrEq("DisableFullPkg"));
 146 }
 147
 148 TEST_F(App2extInterfaceTest, Cleanup) {
 149   // wrong parameters
 150   int ret = app2ext_force_clean_pkg(nullptr);
 151   EXPECT_THAT(ret, testing::Eq(-1));
 152
 153   // normal
 154   ret = app2ext_force_clean_pkg("not.exists.package");
 155   EXPECT_THAT(ret, testing::Eq(0));
 156   EXPECT_THAT(__last_method_name, testing::StrEq("ForceClean"));
 157   gchar* pkgid;
 158   gint uid;
 159   g_variant_get(__last_parameters, "(si)", &pkgid, &uid);
 160   EXPECT_THAT(pkgid, testing::StrEq("not.exists.package"));
 161   g_free(pkgid);
 162 }
 163
 164 TEST_F(App2extInterfaceTest, Migrate) {
 165   int ret = app2ext_migrate_legacy_all();
 166   EXPECT_THAT(ret, testing::Eq(0));
 167   EXPECT_THAT(__last_method_name, testing::StrEq("MigrateLegacyAll"));
 168 }
 169
 170 TEST_F(App2extInterfaceTest, Get) {
 171   // wrong parameter
 172   char* ret = app2ext_usr_getname_image(nullptr, 0);
 173   EXPECT_THAT(ret, testing::Eq(nullptr));
 174   ret = app2ext_usr_get_image_path(nullptr, 0);
 175   EXPECT_THAT(ret, testing::Eq(nullptr));
 176
 177   ret = app2ext_usr_getname_image("not.exists.package", 0);
 178   EXPECT_TRUE(ret != nullptr);
 179 }
 180
 181 TEST_F(App2extInterfaceTest, Install) {
 182   // wrong
 183   app2ext_handle* handle = app2ext_init(APP2EXT_SD_CARD);
 184   int ret = handle->interface.client_pre_install(nullptr, nullptr, 0);
 185   EXPECT_THAT(ret, testing::Eq(APP2EXT_ERROR_INVALID_ARGUMENTS));
 186   ret = handle->interface.client_post_install(nullptr, APP2EXT_STATUS_FAILED);
 187   EXPECT_THAT(ret, testing::Eq(APP2EXT_ERROR_INVALID_ARGUMENTS));
 188
 189   // normal
 190   GList* dir_list = nullptr;
 191   app2ext_dir_details* d1 = new app2ext_dir_details();
 192   app2ext_dir_details* d2 = new app2ext_dir_details();
 193   app2ext_dir_details* d3 = new app2ext_dir_details();
 194   d1->name = g_strdup("d1");
 195   d1->type = APP2EXT_DIR_RO;
 196   d2->name = g_strdup("d2");
 197   d2->type = APP2EXT_DIR_RO;
 198   d3->name = g_strdup("d3");
 199   d3->type = APP2EXT_DIR_RO;
 200
 201   dir_list = g_list_append(dir_list, d1);
 202   dir_list = g_list_append(dir_list, d2);
 203   dir_list = g_list_append(dir_list, d3);
 204   ret = handle->interface.client_pre_install("not.exists.package", dir_list,
 205      1/*megabyte*/);
 206   EXPECT_THAT(ret, testing::Eq(0));
 207   EXPECT_THAT(__last_method_name, testing::StrEq("PreAppInstall"));
 208   g_list_free(dir_list);
 209   g_free(d1->name);
 210   g_free(d2->name);
 211   g_free(d3->name);
 212   delete d1;
 213   delete d2;
 214   delete d3;
 215
 216   ret = handle->interface.client_post_install("not.exists.package",
 217           APP2EXT_STATUS_SUCCESS);
 218   EXPECT_THAT(ret, testing::Eq(0));
 219   EXPECT_THAT(__last_method_name, testing::StrEq("PostAppInstall"));
 220   char* pkgid;
 221   int status;
 222   g_variant_get(__last_parameters, "(sii)", &pkgid, &status, nullptr);
 223   EXPECT_THAT(pkgid, testing::StrEq("not.exists.package"));
 224   EXPECT_THAT(status, testing::Eq(APP2EXT_STATUS_SUCCESS));
 225   g_free(pkgid);
 226   app2ext_deinit(handle);
 227 }
 228
 229 TEST_F(App2extInterfaceTest, Upgrade) {
 230   // wrong
 231   app2ext_handle* handle = app2ext_init(APP2EXT_SD_CARD);
 232   int ret = handle->interface.client_pre_upgrade(nullptr, nullptr, 0);
 233   EXPECT_THAT(ret, testing::Eq(APP2EXT_ERROR_INVALID_ARGUMENTS));
 234   ret = handle->interface.client_post_upgrade(nullptr, APP2EXT_STATUS_FAILED);
 235   EXPECT_THAT(ret, testing::Eq(APP2EXT_ERROR_INVALID_ARGUMENTS));
 236
 237   // normal
 238   GList* dir_list = nullptr;
 239   app2ext_dir_details* d1 = new app2ext_dir_details();
 240   app2ext_dir_details* d2 = new app2ext_dir_details();
 241   app2ext_dir_details* d3 = new app2ext_dir_details();
 242   d1->name = g_strdup("d1");
 243   d1->type = APP2EXT_DIR_RO;
 244   d2->name = g_strdup("d2");
 245   d2->type = APP2EXT_DIR_RO;
 246   d3->name = g_strdup("d3");
 247   d3->type = APP2EXT_DIR_RO;
 248
 249   dir_list = g_list_append(dir_list, d1);
 250   dir_list = g_list_append(dir_list, d2);
 251   dir_list = g_list_append(dir_list, d3);
 252   ret = handle->interface.client_pre_upgrade("not.exists.package", dir_list,
 253      1/*megabyte*/);
 254   EXPECT_THAT(ret, testing::Eq(0));
 255   EXPECT_THAT(__last_method_name, testing::StrEq("PreAppUpgrade"));
 256   g_list_free(dir_list);
 257   g_free(d1->name);
 258   g_free(d2->name);
 259   g_free(d3->name);
 260   delete d1;
 261   delete d2;
 262   delete d3;
 263
 264   ret = handle->interface.client_post_upgrade("not.exists.package",
 265           APP2EXT_STATUS_SUCCESS);
 266   EXPECT_THAT(ret, testing::Eq(0));
 267   EXPECT_THAT(__last_method_name, testing::StrEq("PostAppUpgrade"));
 268   char* pkgid;
 269   int status;
 270   g_variant_get(__last_parameters, "(sii)", &pkgid, &status, nullptr);
 271   EXPECT_THAT(pkgid, testing::StrEq("not.exists.package"));
 272   EXPECT_THAT(status, testing::Eq(APP2EXT_STATUS_SUCCESS));
 273   g_free(pkgid);
 274   app2ext_deinit(handle);
 275 }
 276
 277 TEST_F(App2extInterfaceTest, Uninstall) {
 278   // wrong
 279   app2ext_handle* handle = app2ext_init(APP2EXT_SD_CARD);
 280   int ret = handle->interface.client_pre_uninstall(nullptr);
 281   EXPECT_THAT(ret, testing::Eq(APP2EXT_ERROR_INVALID_ARGUMENTS));
 282   ret = handle->interface.client_post_uninstall(nullptr);
 283   EXPECT_THAT(ret, testing::Eq(APP2EXT_ERROR_INVALID_ARGUMENTS));
 284
 285   //normal
 286   ret = handle->interface.client_pre_uninstall("not.exists.package");
 287   EXPECT_THAT(ret, testing::Eq(0));
 288   EXPECT_THAT(__last_method_name, testing::StrEq("PreAppUninstall"));
 289   char* pkgid;
 290   g_variant_get(__last_parameters, "(si)", &pkgid, nullptr);
 291   EXPECT_THAT(pkgid, testing::StrEq("not.exists.package"));
 292   g_free(pkgid);
 293
 294   ret = handle->interface.client_post_uninstall("not.exists.package");
 295   EXPECT_THAT(ret, testing::Eq(0));
 296   EXPECT_THAT(__last_method_name, testing::StrEq("PostAppUninstall"));
 297   g_variant_get(__last_parameters, "(si)", &pkgid, nullptr);
 298   EXPECT_THAT(pkgid, testing::StrEq("not.exists.package"));
 299   g_free(pkgid);
 300
 301   app2ext_deinit(handle);
 302 }
 303
 304 TEST_F(App2extInterfaceTest, Move) {
 305   // wrong
 306   app2ext_handle* handle = app2ext_init(APP2EXT_SD_CARD);
 307   int ret = handle->interface.client_pre_move(nullptr, nullptr, APP2EXT_MOVE_TO_EXT);
 308   EXPECT_THAT(ret, testing::Eq(APP2EXT_ERROR_INVALID_ARGUMENTS));
 309   ret = handle->interface.client_post_move(nullptr, APP2EXT_MOVE_TO_EXT);
 310   EXPECT_THAT(ret, testing::Eq(APP2EXT_ERROR_INVALID_ARGUMENTS));
 311
 312   //normal
 313   GList* dir_list = nullptr;
 314   app2ext_dir_details* d1 = new app2ext_dir_details();
 315   d1->name = g_strdup("d1");
 316   d1->type = APP2EXT_DIR_RO;
 317
 318   dir_list = g_list_append(dir_list, d1);
 319   ret = handle->interface.client_pre_move("not.exists.package", dir_list, APP2EXT_MOVE_TO_EXT);
 320   EXPECT_THAT(ret, testing::Eq(0));
 321   EXPECT_THAT(__last_method_name, testing::StrEq("PreMoveInstalledApp"));
 322   g_list_free(dir_list);
 323   g_free(d1->name);
 324   delete d1;
 325
 326   ret = handle->interface.client_post_move("not.exists.package", APP2EXT_MOVE_TO_EXT);
 327   EXPECT_THAT(ret, testing::Eq(0));
 328   EXPECT_THAT(__last_method_name, testing::StrEq("PostMoveInstalledApp"));
 329   app2ext_deinit(handle);
 330 }
 331
 332 } // namespace
 333
 334 namespace app2sd {
 335
 336 extern "C" void* dlopen(const char* path, int flag) {
 337   return dlmopen(LM_ID_BASE, "libapp2sd.so", flag);
 338 }
 339
 340 class App2sdEnvironment : public ::testing::Environment {
 341  public:
 342   void SetUp() override {
 343     dl_handle_ = dlopen("/usr/bin/libapp2sd.so", RTLD_LAZY|RTLD_GLOBAL);
 344     if (dl_handle_ == nullptr)
 345       abort();
 346   }
 347
 348   void TearDown() override {
 349     dlclose(dl_handle_);
 350   }
 351
 352   void* dl_handle_;
 353 };
 354
 355 } // namespace app2sd
 356
 357 int main(int argc, char* argv[]) {
 358   try {
 359     ::testing::InitGoogleTest(&argc, argv);
 360     ::env = testing::AddGlobalTestEnvironment(new app2sd::App2sdEnvironment);
 361     return RUN_ALL_TESTS();
 362   } catch (...) {
 363     std::cerr << "Exception occurred" << std::endl;
 364     return -1;
 365   }
 366 }