tests/unit_tests/src/test_shortcut_manager.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 <stdlib.h>
  18 #include <gtest/gtest.h>
  19 #include <shortcut_manager.h>
  20 #include <stdio.h>
  21
  22 #include <memory>
  23
  24 #include "system_info_mock.h"
  25 #include "gio_mock.h"
  26 #include "test_fixture.h"
  27 #include <glib.h>
  28
  29 using ::testing::_;
  30 using ::testing::DoAll;
  31 using ::testing::Return;
  32 using ::testing::SetArgPointee;
  33 using ::testing::SaveArg;
  34
  35 class Mocks : public ::testing::NiceMock<SystemInfoMock>,
  36               public ::testing::NiceMock<GioMock> {};
  37
  38 class ShortcutTest : public TestFixture {
  39  public:
  40   ShortcutTest() : TestFixture(std::make_unique<Mocks>()) {}
  41   virtual ~ShortcutTest() {}
  42
  43   virtual void SetUp() {
  44   }
  45
  46   virtual void TearDown() {
  47   }
  48 };
  49
  50 TEST_F(ShortcutTest, shortcut_add_to_home) {
  51   int ret;
  52   bool is_supported = true;
  53   GDBusConnection* _conn = (GDBusConnection*)g_object_new(G_TYPE_OBJECT, nullptr);
  54   GDBusMessage* _msg = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, nullptr);
  55   GDBusMessage* _msg2 = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, nullptr);
  56   GDBusMessage* _msg3 = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, nullptr);
  57   GDBusMessage* _msg4 = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, nullptr);
  58   GVariant* reply_body;
  59   GAsyncReadyCallback async_cb;
  60   gpointer async_cb_data;
  61
  62   EXPECT_CALL(GetMock<SystemInfoMock>(),
  63       system_info_get_platform_bool(_, _)).
  64       WillOnce(DoAll(SetArgPointee<1>(is_supported),
  65                             Return(0)));
  66
  67   EXPECT_CALL(GetMock<GioMock>(),
  68       g_dbus_message_new_method_call(_, _, _, _)).
  69       WillOnce(Return(_msg)).
  70       WillOnce(Return(_msg2));
  71
  72   EXPECT_CALL(GetMock<GioMock>(),
  73       g_dbus_connection_send_message_with_reply_sync(
  74         _, _, _, _, _, _, _)).
  75       WillOnce(Return(_msg3));
  76
  77   EXPECT_CALL(GetMock<GioMock>(),
  78       g_dbus_connection_send_message_with_reply(
  79         _, _, _, _, _, _, _, _)).
  80       WillOnce(DoAll(SaveArg<6>(&async_cb), SaveArg<7>(&async_cb_data)));
  81
  82   EXPECT_CALL(GetMock<GioMock>(),
  83       g_dbus_message_to_gerror(_, _)).
  84       WillOnce(Return(FALSE));
  85
  86   ret = shortcut_add_to_home("test_name", LAUNCH_BY_URI, "test_uri", "test_icon",
  87                             0, nullptr, nullptr);
  88
  89   EXPECT_EQ(ret, SHORTCUT_ERROR_NONE);
  90
  91   EXPECT_CALL(GetMock<GioMock>(),
  92       g_dbus_connection_send_message_with_reply_finish(_, _, _)).
  93       WillOnce(Return(_msg4));
  94
  95   reply_body = g_variant_new("(i)", 0);
  96
  97   EXPECT_CALL(GetMock<GioMock>(),
  98       g_dbus_message_get_body(_)).
  99       WillOnce(Return(g_variant_ref(reply_body)));
 100
 101   EXPECT_CALL(GetMock<GioMock>(),
 102       g_dbus_message_to_gerror(_, _)).
 103       WillOnce(Return(FALSE));
 104
 105   async_cb((GObject*)_conn, nullptr, async_cb_data);
 106
 107   g_variant_unref(reply_body);
 108 }
 109
 110 TEST_F(ShortcutTest, shortcut_remove_from_home) {
 111   int ret;
 112   bool is_supported = true;
 113   GDBusConnection* _conn = (GDBusConnection*)g_object_new(G_TYPE_OBJECT, nullptr);
 114   GDBusMessage* _msg = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, nullptr);
 115   GDBusMessage* _msg2 = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, nullptr);
 116   GDBusMessage* _msg3 = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, nullptr);
 117   GDBusMessage* _msg4 = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, nullptr);
 118   GVariant* reply_body;
 119   GAsyncReadyCallback async_cb;
 120   gpointer async_cb_data;
 121
 122   EXPECT_CALL(GetMock<SystemInfoMock>(),
 123       system_info_get_platform_bool(_, _)).
 124       WillOnce(DoAll(SetArgPointee<1>(is_supported),
 125                             Return(0)));
 126
 127   EXPECT_CALL(GetMock<GioMock>(),
 128       g_dbus_message_new_method_call(_, _, _, _)).
 129       WillOnce(Return(_msg)).
 130       WillOnce(Return(_msg2));
 131
 132   EXPECT_CALL(GetMock<GioMock>(),
 133       g_dbus_connection_send_message_with_reply_sync(
 134         _, _, _, _, _, _, _)).
 135       WillOnce(Return(_msg3));
 136
 137   EXPECT_CALL(GetMock<GioMock>(),
 138       g_dbus_connection_send_message_with_reply(
 139         _, _, _, _, _, _, _, _)).
 140       WillOnce(DoAll(SaveArg<6>(&async_cb), SaveArg<7>(&async_cb_data)));
 141
 142   EXPECT_CALL(GetMock<GioMock>(),
 143       g_dbus_message_to_gerror(_, _)).
 144       WillOnce(Return(FALSE));
 145
 146   ret = shortcut_remove_from_home("test_name",
 147           [](int ret, void* user_data) -> int {
 148             return 0;
 149           } ,nullptr);
 150
 151   EXPECT_EQ(ret, SHORTCUT_ERROR_NONE);
 152
 153   EXPECT_CALL(GetMock<GioMock>(),
 154       g_dbus_connection_send_message_with_reply_finish(_, _, _)).
 155       WillOnce(Return(_msg4));
 156
 157   reply_body = g_variant_new("(i)", 0);
 158
 159   EXPECT_CALL(GetMock<GioMock>(),
 160       g_dbus_message_get_body(_)).
 161       WillOnce(Return(g_variant_ref(reply_body)));
 162
 163   EXPECT_CALL(GetMock<GioMock>(),
 164       g_dbus_message_to_gerror(_, _)).
 165       WillOnce(Return(FALSE));
 166
 167   async_cb((GObject*)_conn, nullptr, async_cb_data);
 168
 169   g_variant_unref(reply_body);
 170 }
 171
 172 TEST_F(ShortcutTest, shortcut_get_list) {
 173   int ret;
 174   bool is_supported = true;
 175   GVariantBuilder *builder;
 176   GVariant* body;
 177   GVariant* reply_body;
 178   GDBusMessage* _msg = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, nullptr);
 179   GDBusMessage* _msg2 = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, nullptr);
 180
 181   body = g_variant_new("(sssss)",
 182           "test_pkg", "test_icon", "test_name", "test_extra", "");
 183
 184   builder = g_variant_builder_new(G_VARIANT_TYPE("a(v)"));
 185   g_variant_builder_add(builder, "(v)", body);
 186
 187   reply_body = g_variant_new("(ia(v))", 1, builder);
 188
 189   EXPECT_CALL(GetMock<SystemInfoMock>(),
 190       system_info_get_platform_bool(_, _)).
 191       WillOnce(DoAll(SetArgPointee<1>(is_supported),
 192                             Return(0)));
 193
 194   EXPECT_CALL(GetMock<GioMock>(),
 195       g_dbus_message_new_method_call(_, _, _, _)).
 196       WillOnce(Return(_msg));
 197
 198   EXPECT_CALL(GetMock<GioMock>(),
 199       g_dbus_connection_send_message_with_reply_sync(
 200         _, _, _, _, _, _, _)).
 201       WillOnce(Return(_msg2));
 202
 203   EXPECT_CALL(GetMock<GioMock>(),
 204       g_dbus_message_get_body(_)).
 205       WillOnce(Return(reply_body));
 206
 207   EXPECT_CALL(GetMock<GioMock>(),
 208       g_dbus_message_to_gerror(_, _)).
 209       WillOnce(Return(FALSE));
 210
 211   ret = shortcut_get_list("test_pkgid",
 212           [](const char* package_name, const char* icon,
 213               const char* name, const char* extra_key,
 214               const char* extra_data, void* user_data) -> int {
 215             return 0;
 216           }, nullptr);
 217
 218   g_variant_builder_unref(builder);
 219   g_variant_unref(body);
 220
 221   EXPECT_EQ(ret, 1);
 222 }
 223
 224 TEST_F(ShortcutTest, shortcut_set_request_cb) {
 225   int ret;
 226   bool is_supported = true;
 227   GDBusMessage* _msg = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, nullptr);
 228   GDBusMessage* _msg2 = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, nullptr);
 229
 230   EXPECT_CALL(GetMock<SystemInfoMock>(),
 231       system_info_get_platform_bool(_, _)).
 232       WillOnce(DoAll(SetArgPointee<1>(is_supported),
 233                             Return(0)));
 234
 235   EXPECT_CALL(GetMock<GioMock>(),
 236       g_dbus_connection_signal_subscribe(
 237         _, _, _, _, _, _, _, _, _, _)).
 238       WillOnce(Return(99));
 239
 240   EXPECT_CALL(GetMock<GioMock>(),
 241       g_dbus_message_new_method_call(_, _, _, _)).
 242       WillOnce(Return(_msg));
 243
 244   EXPECT_CALL(GetMock<GioMock>(),
 245       g_dbus_connection_send_message_with_reply_sync(
 246         _, _, _, _, _, _, _)).
 247       WillOnce(Return(_msg2));
 248
 249   EXPECT_CALL(GetMock<GioMock>(),
 250       g_bus_watch_name_on_connection(
 251         _, _, _, _, _, _, _)).
 252       WillOnce(Return(88));
 253
 254   EXPECT_CALL(GetMock<GioMock>(),
 255       g_dbus_message_to_gerror(_, _)).
 256       WillOnce(Return(FALSE));
 257
 258   ret = shortcut_set_request_cb(
 259           [](const char* package_name, const char* name,
 260               int type, const char* content_info, const char* icon,
 261               int pid, double period, int allow_duplicate,
 262               void* user_data) -> int {
 263             return 0;
 264           } ,nullptr);
 265
 266   EXPECT_EQ(ret, SHORTCUT_ERROR_NONE);
 267 }
 268
 269 TEST_F(ShortcutTest, shortcut_unset_request_cb) {
 270   bool is_supported = true;
 271   GDBusMessage* _msg = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, nullptr);
 272   GDBusMessage* _msg2 = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, nullptr);
 273
 274   EXPECT_CALL(GetMock<SystemInfoMock>(),
 275       system_info_get_platform_bool(_, _)).
 276       WillOnce(DoAll(SetArgPointee<1>(is_supported),
 277                             Return(0)));
 278
 279   EXPECT_CALL(GetMock<GioMock>(),
 280       g_dbus_message_new_method_call(_, _, _, _)).
 281       WillOnce(Return(_msg));
 282
 283   EXPECT_CALL(GetMock<GioMock>(),
 284       g_dbus_connection_send_message_with_reply_sync(
 285         _, _, _, _, _, _, _)).
 286       WillOnce(Return(_msg2));
 287
 288   EXPECT_CALL(GetMock<GioMock>(),
 289       g_dbus_message_to_gerror(_, _)).
 290       WillOnce(Return(FALSE));
 291
 292   shortcut_unset_request_cb();
 293
 294   EXPECT_EQ(get_last_result(), SHORTCUT_ERROR_NONE);
 295 }
 296
 297 TEST_F(ShortcutTest, shortcut_set_remove_cb) {
 298   int ret;
 299   bool is_supported = true;
 300   GDBusConnection* _conn = (GDBusConnection*)g_object_new(G_TYPE_OBJECT, nullptr);
 301   GDBusMessage* _msg = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, nullptr);
 302   GDBusMessage* _msg2 = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, nullptr);
 303
 304   EXPECT_CALL(GetMock<SystemInfoMock>(),
 305       system_info_get_platform_bool(_, _)).
 306       WillOnce(DoAll(SetArgPointee<1>(is_supported),
 307                             Return(0)));
 308
 309   EXPECT_CALL(GetMock<GioMock>(),
 310       g_bus_get_sync(_, _, _)).
 311       WillOnce(Return(_conn));
 312
 313   EXPECT_CALL(GetMock<GioMock>(),
 314       g_dbus_connection_signal_subscribe(
 315         _, _, _, _, _, _, _, _, _, _)).
 316       WillOnce(Return(99));
 317
 318   EXPECT_CALL(GetMock<GioMock>(),
 319       g_dbus_message_new_method_call(_, _, _, _)).
 320       WillOnce(Return(_msg));
 321
 322   EXPECT_CALL(GetMock<GioMock>(),
 323       g_dbus_connection_send_message_with_reply_sync(
 324         _, _, _, _, _, _, _)).
 325       WillOnce(Return(_msg2));
 326
 327   EXPECT_CALL(GetMock<GioMock>(),
 328       g_bus_watch_name_on_connection(
 329         _, _, _, _, _, _, _)).
 330       WillOnce(Return(88));
 331
 332   EXPECT_CALL(GetMock<GioMock>(),
 333       g_dbus_message_to_gerror(_, _)).
 334       WillOnce(Return(FALSE));
 335
 336   ret = shortcut_set_remove_cb(
 337           [](const char* package_name, const char* name,
 338               int sender_pid, void* user_data) -> int {
 339             return 0;
 340           } ,nullptr);
 341
 342   EXPECT_EQ(ret, SHORTCUT_ERROR_NONE);
 343 }
 344
 345 TEST_F(ShortcutTest, shortcut_unset_remove_cb) {
 346   bool is_supported = true;
 347   GDBusMessage* _msg = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, nullptr);
 348   GDBusMessage* _msg2 = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, nullptr);
 349
 350   EXPECT_CALL(GetMock<SystemInfoMock>(),
 351       system_info_get_platform_bool(_, _)).
 352       WillOnce(DoAll(SetArgPointee<1>(is_supported),
 353                             Return(0)));
 354
 355   EXPECT_CALL(GetMock<GioMock>(),
 356       g_dbus_message_new_method_call(_, _, _, _)).
 357       WillOnce(Return(_msg));
 358
 359   EXPECT_CALL(GetMock<GioMock>(),
 360       g_dbus_connection_send_message_with_reply_sync(
 361         _, _, _, _, _, _, _)).
 362       WillOnce(Return(_msg2));
 363
 364   EXPECT_CALL(GetMock<GioMock>(),
 365       g_dbus_message_to_gerror(_, _)).
 366       WillOnce(Return(FALSE));
 367
 368   shortcut_unset_remove_cb();
 369
 370   EXPECT_EQ(get_last_result(), SHORTCUT_ERROR_NONE);
 371 }
 372
 373 TEST_F(ShortcutTest, shortcut_add_to_home_widget) {
 374   int ret;
 375   bool is_supported = true;
 376   GDBusConnection* _conn = (GDBusConnection*)g_object_new(G_TYPE_OBJECT, nullptr);
 377   GDBusMessage* _msg = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, nullptr);
 378   GDBusMessage* _msg2 = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, nullptr);
 379   GDBusMessage* _msg3 = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, nullptr);
 380   GDBusMessage* _msg4 = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, nullptr);
 381   GVariant* reply_body;
 382   GAsyncReadyCallback async_cb;
 383   gpointer async_cb_data;
 384
 385   EXPECT_CALL(GetMock<SystemInfoMock>(),
 386       system_info_get_platform_bool(_, _)).
 387       WillOnce(DoAll(SetArgPointee<1>(is_supported),
 388                             Return(0)));
 389
 390   EXPECT_CALL(GetMock<GioMock>(),
 391       g_bus_get_sync(_, _, _)).
 392       WillOnce(Return(_conn));
 393
 394   EXPECT_CALL(GetMock<GioMock>(),
 395       g_dbus_message_new_method_call(_, _, _, _)).
 396       WillOnce(Return(_msg)).
 397       WillOnce(Return(_msg2));
 398
 399   EXPECT_CALL(GetMock<GioMock>(),
 400       g_dbus_connection_send_message_with_reply_sync(
 401         _, _, _, _, _, _, _)).
 402       WillOnce(Return(_msg3));
 403
 404   EXPECT_CALL(GetMock<GioMock>(),
 405       g_dbus_connection_send_message_with_reply(
 406         _, _, _, _, _, _, _, _)).
 407       WillOnce(DoAll(SaveArg<6>(&async_cb), SaveArg<7>(&async_cb_data)));
 408
 409   EXPECT_CALL(GetMock<GioMock>(),
 410       g_dbus_message_to_gerror(_, _)).
 411       WillOnce(Return(FALSE));
 412
 413   ret = shortcut_add_to_home_widget("test_name", WIDGET_SIZE_DEFAULT, "test_id", "test_icon",
 414                             0, 0, nullptr, nullptr);
 415
 416   EXPECT_EQ(ret, SHORTCUT_ERROR_NONE);
 417
 418   EXPECT_CALL(GetMock<GioMock>(),
 419       g_dbus_connection_send_message_with_reply_finish(_, _, _)).
 420       WillOnce(Return(_msg4));
 421
 422   reply_body = g_variant_new("(i)", 0);
 423
 424   EXPECT_CALL(GetMock<GioMock>(),
 425       g_dbus_message_get_body(_)).
 426       WillOnce(Return(g_variant_ref(reply_body)));
 427
 428   EXPECT_CALL(GetMock<GioMock>(),
 429       g_dbus_message_to_gerror(_, _)).
 430       WillOnce(Return(FALSE));
 431
 432   async_cb((GObject*)_conn, nullptr, async_cb_data);
 433
 434   g_variant_unref(reply_body);
 435 }