tests/unit_tests/src/test_badge_service.cc

   1 /*
   2  * Copyright (c) 2022 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 "include/service_common.h"
  20 #include "include/badge_service.h"
  21 #include "tests/mock/badge_mock.h"
  22 #include "tests/mock/gio_mock.h"
  23 #include "tests/mock/tzplatform_config_mock.h"
  24 #include "tests/mock/test_fixture.h"
  25
  26 using ::testing::_;
  27 using ::testing::DoAll;
  28 using ::testing::Return;
  29 using ::testing::SetArgPointee;
  30
  31 namespace {
  32
  33 class Mocks : public ::testing::NiceMock<BadgeMock>,
  34     public ::testing::NiceMock<GioMock>,
  35     public ::testing::NiceMock<TzplatformConfigMock> {};
  36
  37 }  //namespace
  38
  39 class BadgeServiceTest : public TestFixture {
  40  public:
  41   BadgeServiceTest() : TestFixture(std::make_unique<Mocks>()) {}
  42   virtual ~BadgeServiceTest() {}
  43
  44   virtual void SetUp() {
  45       EXPECT_CALL(GetMock<TzplatformConfigMock>(), tzplatform_getuid(_))
  46       .WillRepeatedly(Return(6001));
  47   }
  48
  49   virtual void TearDown() {
  50   }
  51 };
  52
  53 TEST_F(BadgeServiceTest, badge_service_init) {
  54   GDBusNodeInfo* info = reinterpret_cast<GDBusNodeInfo*>(
  55       malloc(sizeof(GDBusNodeInfo)));
  56   info->interfaces = reinterpret_cast<GDBusInterfaceInfo**>(
  57       malloc(sizeof(GDBusInterfaceInfo*)));
  58   GDBusConnection* conn = reinterpret_cast<GDBusConnection*>(calloc(1, 4));
  59   EXPECT_CALL(GetMock<BadgeMock>(), badge_db_init())
  60       .WillOnce(Return(0));
  61   EXPECT_CALL(GetMock<GioMock>(), g_bus_own_name(_, _, _, _, _, _, _, _))
  62       .WillOnce(Return(1));
  63   EXPECT_CALL(GetMock<GioMock>(), g_bus_get_sync(_, _, _))
  64       .WillOnce(Return(conn));
  65   EXPECT_CALL(GetMock<GioMock>(), g_dbus_node_info_new_for_xml(_, _))
  66       .WillOnce(Return(info));
  67   EXPECT_CALL(GetMock<GioMock>(), g_dbus_node_info_unref(_))
  68       .WillOnce(Return());
  69   EXPECT_CALL(GetMock<GioMock>(), g_dbus_connection_register_object(_, _, _, _, _, _, _))
  70       .WillOnce(Return(1));
  71
  72   int ret = badge_service_init();
  73   EXPECT_EQ(ret, BADGE_ERROR_NONE);
  74
  75   free(info->interfaces);
  76   free(info);
  77   free(conn);
  78 }
  79
  80 TEST_F(BadgeServiceTest, badge_service_fini) {
  81   int ret = badge_service_fini();
  82   EXPECT_EQ(ret, BADGE_ERROR_NONE);
  83 }
  84
  85 TEST_F(BadgeServiceTest, badge_get_badge_existing) {
  86   EXPECT_CALL(GetMock<BadgeMock>(), badge_db_is_existing(_, _, _))
  87       .WillOnce(Return(0));
  88   GVariant* param = g_variant_new("(si)", "pkgname", 5001);
  89   GVariant* reply;
  90   int ret = badge_get_badge_existing(param, &reply, 5001);
  91   EXPECT_EQ(ret, BADGE_ERROR_NONE);
  92
  93   g_object_unref(param);
  94   g_object_unref(reply);
  95 }
  96
  97 TEST_F(BadgeServiceTest, badge_get_badge_list) {
  98   EXPECT_CALL(GetMock<BadgeMock>(), badge_db_get_list(_, _))
  99       .WillOnce(Return(0));
 100   GVariant* param = g_variant_new("(i)", 5001);
 101   GVariant* reply;
 102   int ret = badge_get_badge_list(param, &reply, 5001);
 103   EXPECT_EQ(ret, BADGE_ERROR_NONE);
 104
 105   g_object_unref(param);
 106   g_object_unref(reply);
 107
 108 }
 109
 110 TEST_F(BadgeServiceTest, badge_insert) {
 111   EXPECT_CALL(GetMock<BadgeMock>(), badge_db_insert(_, _, _, _))
 112       .WillOnce(Return(0));
 113   EXPECT_CALL(GetMock<BadgeMock>(), badge_db_get_allow_to_display_by_appid(_, _,
 114       _)).WillOnce(Return(0));
 115   GVariant* param = g_variant_new("(sssi)", "pkgname", "writable", "call", 5001);
 116   GVariant* reply;
 117   int ret = badge_insert(param, &reply, 5001);
 118   EXPECT_EQ(ret, BADGE_ERROR_NONE);
 119
 120   g_object_unref(param);
 121   g_object_unref(reply);
 122 }
 123
 124 TEST_F(BadgeServiceTest, badge_delete) {
 125   EXPECT_CALL(GetMock<BadgeMock>(), badge_db_delete(_, _, _, _))
 126       .WillOnce(Return(0));
 127   GVariant* param = g_variant_new("(ssi)", "pkgname", "caller", 5001);
 128   GVariant* reply;
 129   int ret = badge_delete(param, &reply, 5001, 10);
 130   EXPECT_EQ(ret, BADGE_ERROR_NONE);
 131
 132   g_object_unref(param);
 133   g_object_unref(reply);
 134 }
 135
 136 TEST_F(BadgeServiceTest, badge_set_badge_count) {
 137   EXPECT_CALL(GetMock<BadgeMock>(), badge_db_set_count(_, _, _, _, _))
 138       .WillOnce(Return(0));
 139   EXPECT_CALL(GetMock<BadgeMock>(), badge_db_get_allow_to_display_by_appid(_, _,
 140       _)).WillOnce(Return(0));
 141   GVariant* param = g_variant_new("(ssii)", "pkgname", "caller", 10, 5001);
 142   GVariant* reply;
 143   int ret = badge_set_badge_count(param, &reply, 5001, 10);
 144   EXPECT_EQ(ret, BADGE_ERROR_NONE);
 145
 146   g_object_unref(param);
 147   g_object_unref(reply);
 148 }
 149
 150 TEST_F(BadgeServiceTest, badge_get_badge_count) {
 151   EXPECT_CALL(GetMock<BadgeMock>(), badge_db_get_count(_, _, _))
 152       .WillOnce(Return(0));
 153   GVariant* param = g_variant_new("(si)", "pkgname", 5001);
 154   GVariant* reply;
 155   int ret = badge_get_badge_count(param, &reply, 5001);
 156   EXPECT_EQ(ret, BADGE_ERROR_NONE);
 157
 158   g_object_unref(param);
 159   g_object_unref(reply);
 160 }
 161
 162 TEST_F(BadgeServiceTest, badge_set_display_option) {
 163   EXPECT_CALL(GetMock<BadgeMock>(), badge_db_set_display_option(_, _, _))
 164       .WillOnce(Return(0));
 165   EXPECT_CALL(GetMock<BadgeMock>(), badge_db_get_allow_to_display_by_appid(_, _,
 166       _)).WillOnce(Return(0));
 167   GVariant* param = g_variant_new("(ssii)", "pkgname", "caller", 1, 5001);
 168   GVariant* reply;
 169   int ret = badge_set_display_option(param, &reply, 5001);
 170   EXPECT_EQ(ret, BADGE_ERROR_NONE);
 171
 172   g_object_unref(param);
 173   g_object_unref(reply);
 174 }
 175
 176 TEST_F(BadgeServiceTest, badge_get_display_option) {
 177   EXPECT_CALL(GetMock<BadgeMock>(), badge_db_get_display_option(_, _, _))
 178       .WillOnce(Return(0));
 179   EXPECT_CALL(GetMock<BadgeMock>(), badge_db_get_allow_to_display_by_appid(_, _,
 180       _)).WillOnce(Return(0));
 181   GVariant* param = g_variant_new("(si)", "pkgname", 5001);
 182   GVariant* reply;
 183   int ret = badge_get_display_option(param, &reply, "sender", 5001);
 184   EXPECT_EQ(ret, BADGE_ERROR_NONE);
 185
 186   g_object_unref(param);
 187   g_object_unref(reply);
 188 }
 189
 190 TEST_F(BadgeServiceTest, badge_update_badge_setting) {
 191   EXPECT_CALL(GetMock<BadgeMock>(), badge_db_update_setting(_, _, _, _))
 192       .WillOnce(Return(0));
 193   GVariant* param = g_variant_new("(ssii)", "pkgname", "caller", 1, 5001);
 194   GVariant* reply;
 195   int ret = badge_update_badge_setting(param, &reply, 5001);
 196   EXPECT_EQ(ret, BADGE_ERROR_NONE);
 197
 198   g_object_unref(param);
 199   g_object_unref(reply);
 200 }
 201
 202 TEST_F(BadgeServiceTest, badge_get_setting_by_appid) {
 203   struct badge_setting* setting =
 204       reinterpret_cast<struct badge_setting*>(malloc(sizeof(struct badge_setting)));
 205   setting->pkgname = strdup("pkgname");
 206   setting->appid = strdup("appid");
 207   setting->allow_to_display = 1;
 208   EXPECT_CALL(GetMock<BadgeMock>(), badge_db_get_setting_by_appid(_, _, _))
 209       .WillOnce(DoAll(SetArgPointee<1>(setting), Return(0)));
 210   GVariant* param = g_variant_new("(si)", "appid", 5001);
 211   GVariant* reply;
 212   int ret = badge_get_setting_by_appid(param, &reply, 5001);
 213   EXPECT_EQ(ret, BADGE_ERROR_NONE);
 214
 215   g_object_unref(param);
 216   g_object_unref(reply);
 217 }
 218
 219 TEST_F(BadgeServiceTest, badge_init_display) {
 220   EXPECT_CALL(GetMock<BadgeMock>(), badge_db_get_list(_, _))
 221       .WillOnce(Return(0));
 222   GVariant* param = g_variant_new("(i)", 5001);
 223   GVariant* reply;
 224   int ret = badge_init_display(param, &reply, 5001);
 225   EXPECT_EQ(ret, BADGE_ERROR_NONE);
 226
 227   g_object_unref(param);
 228   g_object_unref(reply);
 229 }