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