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
  28 using ::testing::_;
  29 using ::testing::DoAll;
  30 using ::testing::Return;
  31 using ::testing::SetArgPointee;
  32
  33 class Mocks : public ::testing::NiceMock<SystemInfoMock>,
  34               public ::testing::NiceMock<GioMock> {};
  35
  36 class ShortcutTest : public TestFixture {
  37  public:
  38   ShortcutTest() : TestFixture(std::make_unique<Mocks>()) {}
  39   virtual ~ShortcutTest() {}
  40
  41   virtual void SetUp() {
  42   }
  43
  44   virtual void TearDown() {
  45   }
  46 };
  47
  48 TEST_F(ShortcutTest, shortcut_add_to_home) {
  49   int ret;
  50   bool is_supported = true;
  51   GDBusConnection* _conn = (GDBusConnection*)g_object_new(G_TYPE_OBJECT, NULL);
  52   GDBusMessage* _msg = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, NULL);
  53   GDBusMessage* _msg2 = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, NULL);
  54   GDBusMessage* _msg3 = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, NULL);
  55
  56   EXPECT_CALL(GetMock<SystemInfoMock>(),
  57       system_info_get_platform_bool(_, _)).
  58       WillOnce(DoAll(SetArgPointee<1>(is_supported),
  59                             Return(0)));
  60
  61   EXPECT_CALL(GetMock<GioMock>(),
  62       g_bus_get_sync(_, _, _)).
  63       WillOnce(Return(_conn));
  64
  65   EXPECT_CALL(GetMock<GioMock>(),
  66       g_dbus_message_new_method_call(_, _, _, _)).
  67       WillOnce(Return(_msg)).
  68       WillOnce(Return(_msg2));
  69
  70   EXPECT_CALL(GetMock<GioMock>(),
  71       g_dbus_connection_send_message_with_reply_sync(
  72         _, _, _, _, _, _, _)).
  73       WillOnce(Return(_msg3));
  74
  75   EXPECT_CALL(GetMock<GioMock>(),
  76       g_dbus_connection_send_message_with_reply(
  77         _, _, _, _, _, _, _, _)).
  78       Times(1);
  79
  80   EXPECT_CALL(GetMock<GioMock>(),
  81       g_dbus_message_to_gerror(_, _)).
  82       WillOnce(Return(FALSE));
  83
  84   ret = shortcut_add_to_home("test_name", LAUNCH_BY_URI, "test_uri", "test_icon",
  85                             0, NULL, NULL);
  86
  87   EXPECT_EQ(ret, SHORTCUT_ERROR_NONE);
  88 }
  89
  90 TEST_F(ShortcutTest, shortcut_remove_from_home) {
  91   int ret;
  92   bool is_supported = true;
  93   GDBusMessage* _msg = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, NULL);
  94   GDBusMessage* _msg2 = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, NULL);
  95   GDBusMessage* _msg3 = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, NULL);
  96
  97   EXPECT_CALL(GetMock<SystemInfoMock>(),
  98       system_info_get_platform_bool(_, _)).
  99       WillOnce(DoAll(SetArgPointee<1>(is_supported),
 100                             Return(0)));
 101
 102   EXPECT_CALL(GetMock<GioMock>(),
 103       g_dbus_message_new_method_call(_, _, _, _)).
 104       WillOnce(Return(_msg)).
 105       WillOnce(Return(_msg2));
 106
 107   EXPECT_CALL(GetMock<GioMock>(),
 108       g_dbus_connection_send_message_with_reply_sync(
 109         _, _, _, _, _, _, _)).
 110       WillOnce(Return(_msg3));
 111
 112   EXPECT_CALL(GetMock<GioMock>(),
 113       g_dbus_connection_send_message_with_reply(
 114         _, _, _, _, _, _, _, _)).
 115       Times(1);
 116
 117   EXPECT_CALL(GetMock<GioMock>(),
 118       g_dbus_message_to_gerror(_, _)).
 119       WillOnce(Return(FALSE));
 120
 121   ret = shortcut_remove_from_home("test_name",
 122           [](int ret, void* user_data) -> int {
 123             return 0;
 124           } ,NULL);
 125
 126   EXPECT_EQ(ret, SHORTCUT_ERROR_NONE);
 127 }
 128
 129 TEST_F(ShortcutTest, shortcut_get_list) {
 130   int ret;
 131   bool is_supported = true;
 132   GVariantBuilder *builder;
 133   GVariant* body;
 134   GVariant* reply_body;
 135   GDBusMessage* _msg = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, NULL);
 136   GDBusMessage* _msg2 = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, NULL);
 137
 138   body = g_variant_new("(sssss)",
 139           "test_pkg", "test_icon", "test_name", "test_extra", "");
 140
 141   builder = g_variant_builder_new(G_VARIANT_TYPE("a(v)"));
 142   g_variant_builder_add(builder, "(v)", body);
 143
 144   reply_body = g_variant_new("(ia(v))", 1, builder);
 145
 146   EXPECT_CALL(GetMock<SystemInfoMock>(),
 147       system_info_get_platform_bool(_, _)).
 148       WillOnce(DoAll(SetArgPointee<1>(is_supported),
 149                             Return(0)));
 150
 151   EXPECT_CALL(GetMock<GioMock>(),
 152       g_dbus_message_new_method_call(_, _, _, _)).
 153       WillOnce(Return(_msg));
 154
 155   EXPECT_CALL(GetMock<GioMock>(),
 156       g_dbus_connection_send_message_with_reply_sync(
 157         _, _, _, _, _, _, _)).
 158       WillOnce(Return(_msg2));
 159
 160   EXPECT_CALL(GetMock<GioMock>(),
 161       g_dbus_message_get_body(_)).
 162       WillOnce(Return(reply_body));
 163
 164   EXPECT_CALL(GetMock<GioMock>(),
 165       g_dbus_message_to_gerror(_, _)).
 166       WillOnce(Return(FALSE));
 167
 168   ret = shortcut_get_list("test_pkgid",
 169           [](const char* package_name, const char* icon,
 170               const char* name, const char* extra_key,
 171               const char* extra_data, void* user_data) -> int {
 172             return 0;
 173           }, NULL);
 174
 175   g_variant_builder_unref(builder);
 176   g_variant_unref(body);
 177
 178   EXPECT_EQ(ret, 1);
 179 }
 180
 181 TEST_F(ShortcutTest, shortcut_set_request_cb) {
 182   int ret;
 183   bool is_supported = true;
 184   GDBusMessage* _msg = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, NULL);
 185   GDBusMessage* _msg2 = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, NULL);
 186
 187   EXPECT_CALL(GetMock<SystemInfoMock>(),
 188       system_info_get_platform_bool(_, _)).
 189       WillOnce(DoAll(SetArgPointee<1>(is_supported),
 190                             Return(0)));
 191
 192   EXPECT_CALL(GetMock<GioMock>(),
 193       g_dbus_connection_signal_subscribe(
 194         _, _, _, _, _, _, _, _, _, _)).
 195       WillOnce(Return(99));
 196
 197   EXPECT_CALL(GetMock<GioMock>(),
 198       g_dbus_message_new_method_call(_, _, _, _)).
 199       WillOnce(Return(_msg));
 200
 201   EXPECT_CALL(GetMock<GioMock>(),
 202       g_dbus_connection_send_message_with_reply_sync(
 203         _, _, _, _, _, _, _)).
 204       WillOnce(Return(_msg2));
 205
 206   EXPECT_CALL(GetMock<GioMock>(),
 207       g_bus_watch_name_on_connection(
 208         _, _, _, _, _, _, _)).
 209       WillOnce(Return(88));
 210
 211   EXPECT_CALL(GetMock<GioMock>(),
 212       g_dbus_message_to_gerror(_, _)).
 213       WillOnce(Return(FALSE));
 214
 215   ret = shortcut_set_request_cb(
 216           [](const char* package_name, const char* name,
 217               int type, const char* content_info, const char* icon,
 218               int pid, double period, int allow_duplicate,
 219               void* user_data) -> int {
 220             return 0;
 221           } ,NULL);
 222
 223   EXPECT_EQ(ret, SHORTCUT_ERROR_NONE);
 224 }
 225
 226 TEST_F(ShortcutTest, shortcut_unset_request_cb) {
 227   bool is_supported = true;
 228   GDBusMessage* _msg = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, NULL);
 229   GDBusMessage* _msg2 = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, NULL);
 230
 231   EXPECT_CALL(GetMock<SystemInfoMock>(),
 232       system_info_get_platform_bool(_, _)).
 233       WillOnce(DoAll(SetArgPointee<1>(is_supported),
 234                             Return(0)));
 235
 236   EXPECT_CALL(GetMock<GioMock>(),
 237       g_dbus_message_new_method_call(_, _, _, _)).
 238       WillOnce(Return(_msg));
 239
 240   EXPECT_CALL(GetMock<GioMock>(),
 241       g_dbus_connection_send_message_with_reply_sync(
 242         _, _, _, _, _, _, _)).
 243       WillOnce(Return(_msg2));
 244
 245   EXPECT_CALL(GetMock<GioMock>(),
 246       g_dbus_message_to_gerror(_, _)).
 247       WillOnce(Return(FALSE));
 248
 249   shortcut_unset_request_cb();
 250
 251   EXPECT_EQ(get_last_result(), SHORTCUT_ERROR_NONE);
 252 }
 253
 254 TEST_F(ShortcutTest, shortcut_set_remove_cb) {
 255   int ret;
 256   bool is_supported = true;
 257   GDBusConnection* _conn = (GDBusConnection*)g_object_new(G_TYPE_OBJECT, NULL);
 258   GDBusMessage* _msg = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, NULL);
 259   GDBusMessage* _msg2 = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, NULL);
 260
 261   EXPECT_CALL(GetMock<SystemInfoMock>(),
 262       system_info_get_platform_bool(_, _)).
 263       WillOnce(DoAll(SetArgPointee<1>(is_supported),
 264                             Return(0)));
 265
 266   EXPECT_CALL(GetMock<GioMock>(),
 267       g_bus_get_sync(_, _, _)).
 268       WillOnce(Return(_conn));
 269
 270   EXPECT_CALL(GetMock<GioMock>(),
 271       g_dbus_connection_signal_subscribe(
 272         _, _, _, _, _, _, _, _, _, _)).
 273       WillOnce(Return(99));
 274
 275   EXPECT_CALL(GetMock<GioMock>(),
 276       g_dbus_message_new_method_call(_, _, _, _)).
 277       WillOnce(Return(_msg));
 278
 279   EXPECT_CALL(GetMock<GioMock>(),
 280       g_dbus_connection_send_message_with_reply_sync(
 281         _, _, _, _, _, _, _)).
 282       WillOnce(Return(_msg2));
 283
 284   EXPECT_CALL(GetMock<GioMock>(),
 285       g_bus_watch_name_on_connection(
 286         _, _, _, _, _, _, _)).
 287       WillOnce(Return(88));
 288
 289   EXPECT_CALL(GetMock<GioMock>(),
 290       g_dbus_message_to_gerror(_, _)).
 291       WillOnce(Return(FALSE));
 292
 293   ret = shortcut_set_remove_cb(
 294           [](const char* package_name, const char* name,
 295               int sender_pid, void* user_data) -> int {
 296             return 0;
 297           } ,NULL);
 298
 299   EXPECT_EQ(ret, SHORTCUT_ERROR_NONE);
 300 }
 301
 302 TEST_F(ShortcutTest, shortcut_unset_remove_cb) {
 303   bool is_supported = true;
 304   GDBusMessage* _msg = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, NULL);
 305   GDBusMessage* _msg2 = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, NULL);
 306
 307   EXPECT_CALL(GetMock<SystemInfoMock>(),
 308       system_info_get_platform_bool(_, _)).
 309       WillOnce(DoAll(SetArgPointee<1>(is_supported),
 310                             Return(0)));
 311
 312   EXPECT_CALL(GetMock<GioMock>(),
 313       g_dbus_message_new_method_call(_, _, _, _)).
 314       WillOnce(Return(_msg));
 315
 316   EXPECT_CALL(GetMock<GioMock>(),
 317       g_dbus_connection_send_message_with_reply_sync(
 318         _, _, _, _, _, _, _)).
 319       WillOnce(Return(_msg2));
 320
 321   EXPECT_CALL(GetMock<GioMock>(),
 322       g_dbus_message_to_gerror(_, _)).
 323       WillOnce(Return(FALSE));
 324
 325   shortcut_unset_remove_cb();
 326
 327   EXPECT_EQ(get_last_result(), SHORTCUT_ERROR_NONE);
 328 }