Improve coverage

[platform/core/appfw/data-provider-master.git] / tests / unit_tests / src / test_badge_service.cc

diff --git a/tests/unit_tests/src/test_badge_service.cc b/tests/unit_tests/src/test_badge_service.cc
index 822d969..c788f74 100644 (file)
--- a/tests/unit_tests/src/test_badge_service.cc
+++ b/tests/unit_tests/src/test_badge_service.cc
@@ -14,25 +14,27 @@
  * limitations under the License.
  */
 
-#include <stdlib.h>
 #include <gtest/gtest.h>
-#include <stdio.h>
-#include <glib.h>
 
-#include <memory>
+#include "include/service_common.h"
+#include "include/badge_service.h"
+#include "tests/mock/badge_mock.h"
+#include "tests/mock/gio_mock.h"
+#include "tests/mock/tzplatform_config_mock.h"
+#include "tests/mock/test_fixture.h"
 
-#include "service_common.h"
-#include "badge_service.h"
-#include "gio_mock.h"
-#include "test_fixture.h"
-
-// using namespace tizen_base;
 using ::testing::_;
 using ::testing::DoAll;
 using ::testing::Return;
 using ::testing::SetArgPointee;
 
-class Mocks : public ::testing::NiceMock<GioMock> {};
+namespace {
+
+class Mocks : public ::testing::NiceMock<BadgeMock>,
+    public ::testing::NiceMock<GioMock>,
+    public ::testing::NiceMock<TzplatformConfigMock> {};
+
+}  //namespace
 
 class BadgeServiceTest : public TestFixture {
  public:
@@ -40,6 +42,8 @@ class BadgeServiceTest : public TestFixture {
   virtual ~BadgeServiceTest() {}
 
   virtual void SetUp() {
+      EXPECT_CALL(GetMock<TzplatformConfigMock>(), tzplatform_getuid(_))
+      .WillRepeatedly(Return(6001));
   }
 
   virtual void TearDown() {
@@ -47,8 +51,179 @@ class BadgeServiceTest : public TestFixture {
 };
 
 TEST_F(BadgeServiceTest, badge_service_init) {
-  int ret;
-  ret = BADGE_ERROR_NONE;
+  GDBusNodeInfo* info = reinterpret_cast<GDBusNodeInfo*>(
+      malloc(sizeof(GDBusNodeInfo)));
+  info->interfaces = reinterpret_cast<GDBusInterfaceInfo**>(
+      malloc(sizeof(GDBusInterfaceInfo*)));
+  GDBusConnection* conn = reinterpret_cast<GDBusConnection*>(calloc(1, 4));
+  EXPECT_CALL(GetMock<BadgeMock>(), badge_db_init())
+      .WillOnce(Return(0));
+  EXPECT_CALL(GetMock<GioMock>(), g_bus_own_name(_, _, _, _, _, _, _, _))
+      .WillOnce(Return(1));
+  EXPECT_CALL(GetMock<GioMock>(), g_bus_get_sync(_, _, _))
+      .WillOnce(Return(conn));
+  EXPECT_CALL(GetMock<GioMock>(), g_dbus_node_info_new_for_xml(_, _))
+      .WillOnce(Return(info));
+  EXPECT_CALL(GetMock<GioMock>(), g_dbus_node_info_unref(_))
+      .WillOnce(Return());
+  EXPECT_CALL(GetMock<GioMock>(), g_dbus_connection_register_object(_, _, _, _, _, _, _))
+      .WillOnce(Return(1));
+
+  int ret = badge_service_init();
+  EXPECT_EQ(ret, BADGE_ERROR_NONE);
+
+  free(info->interfaces);
+  free(info);
+  free(conn);
+}
+
+TEST_F(BadgeServiceTest, badge_service_fini) {
+  int ret = badge_service_fini();
+  EXPECT_EQ(ret, BADGE_ERROR_NONE);
+}
+
+TEST_F(BadgeServiceTest, badge_get_badge_existing) {
+  EXPECT_CALL(GetMock<BadgeMock>(), badge_db_is_existing(_, _, _))
+      .WillOnce(Return(0));
+  GVariant* param = g_variant_new("(si)", "pkgname", 5001);
+  GVariant* reply;
+  int ret = badge_get_badge_existing(param, &reply, 5001);
+  EXPECT_EQ(ret, BADGE_ERROR_NONE);
+
+  g_object_unref(param);
+  g_object_unref(reply);
+}
+
+TEST_F(BadgeServiceTest, badge_get_badge_list) {
+  EXPECT_CALL(GetMock<BadgeMock>(), badge_db_get_list(_, _))
+      .WillOnce(Return(0));
+  GVariant* param = g_variant_new("(i)", 5001);
+  GVariant* reply;
+  int ret = badge_get_badge_list(param, &reply, 5001);
+  EXPECT_EQ(ret, BADGE_ERROR_NONE);
+
+  g_object_unref(param);
+  g_object_unref(reply);
+
+}
+
+TEST_F(BadgeServiceTest, badge_insert) {
+  EXPECT_CALL(GetMock<BadgeMock>(), badge_db_insert(_, _, _, _))
+      .WillOnce(Return(0));
+  EXPECT_CALL(GetMock<BadgeMock>(), badge_db_get_allow_to_display_by_appid(_, _,
+      _)).WillOnce(Return(0));
+  GVariant* param = g_variant_new("(sssi)", "pkgname", "writable", "call", 5001);
+  GVariant* reply;
+  int ret = badge_insert(param, &reply, 5001);
   EXPECT_EQ(ret, BADGE_ERROR_NONE);
 
+  g_object_unref(param);
+  g_object_unref(reply);
 }
+
+TEST_F(BadgeServiceTest, badge_delete) {
+  EXPECT_CALL(GetMock<BadgeMock>(), badge_db_delete(_, _, _, _))
+      .WillOnce(Return(0));
+  GVariant* param = g_variant_new("(ssi)", "pkgname", "caller", 5001);
+  GVariant* reply;
+  int ret = badge_delete(param, &reply, 5001, 10);
+  EXPECT_EQ(ret, BADGE_ERROR_NONE);
+
+  g_object_unref(param);
+  g_object_unref(reply);
+}
+
+TEST_F(BadgeServiceTest, badge_set_badge_count) {
+  EXPECT_CALL(GetMock<BadgeMock>(), badge_db_set_count(_, _, _, _, _))
+      .WillOnce(Return(0));
+  EXPECT_CALL(GetMock<BadgeMock>(), badge_db_get_allow_to_display_by_appid(_, _,
+      _)).WillOnce(Return(0));
+  GVariant* param = g_variant_new("(ssii)", "pkgname", "caller", 10, 5001);
+  GVariant* reply;
+  int ret = badge_set_badge_count(param, &reply, 5001, 10);
+  EXPECT_EQ(ret, BADGE_ERROR_NONE);
+
+  g_object_unref(param);
+  g_object_unref(reply);
+}
+
+TEST_F(BadgeServiceTest, badge_get_badge_count) {
+  EXPECT_CALL(GetMock<BadgeMock>(), badge_db_get_count(_, _, _))
+      .WillOnce(Return(0));
+  GVariant* param = g_variant_new("(si)", "pkgname", 5001);
+  GVariant* reply;
+  int ret = badge_get_badge_count(param, &reply, 5001);
+  EXPECT_EQ(ret, BADGE_ERROR_NONE);
+
+  g_object_unref(param);
+  g_object_unref(reply);
+}
+
+TEST_F(BadgeServiceTest, badge_set_display_option) {
+  EXPECT_CALL(GetMock<BadgeMock>(), badge_db_set_display_option(_, _, _))
+      .WillOnce(Return(0));
+  EXPECT_CALL(GetMock<BadgeMock>(), badge_db_get_allow_to_display_by_appid(_, _,
+      _)).WillOnce(Return(0));
+  GVariant* param = g_variant_new("(ssii)", "pkgname", "caller", 1, 5001);
+  GVariant* reply;
+  int ret = badge_set_display_option(param, &reply, 5001);
+  EXPECT_EQ(ret, BADGE_ERROR_NONE);
+
+  g_object_unref(param);
+  g_object_unref(reply);
+}
+
+TEST_F(BadgeServiceTest, badge_get_display_option) {
+  EXPECT_CALL(GetMock<BadgeMock>(), badge_db_get_display_option(_, _, _))
+      .WillOnce(Return(0));
+  EXPECT_CALL(GetMock<BadgeMock>(), badge_db_get_allow_to_display_by_appid(_, _,
+      _)).WillOnce(Return(0));
+  GVariant* param = g_variant_new("(si)", "pkgname", 5001);
+  GVariant* reply;
+  int ret = badge_get_display_option(param, &reply, "sender", 5001);
+  EXPECT_EQ(ret, BADGE_ERROR_NONE);
+
+  g_object_unref(param);
+  g_object_unref(reply);
+}
+
+TEST_F(BadgeServiceTest, badge_update_badge_setting) {
+  EXPECT_CALL(GetMock<BadgeMock>(), badge_db_update_setting(_, _, _, _))
+      .WillOnce(Return(0));
+  GVariant* param = g_variant_new("(ssii)", "pkgname", "caller", 1, 5001);
+  GVariant* reply;
+  int ret = badge_update_badge_setting(param, &reply, 5001);
+  EXPECT_EQ(ret, BADGE_ERROR_NONE);
+
+  g_object_unref(param);
+  g_object_unref(reply);
+}
+
+TEST_F(BadgeServiceTest, badge_get_setting_by_appid) {
+  struct badge_setting* setting =
+      reinterpret_cast<struct badge_setting*>(malloc(sizeof(struct badge_setting)));
+  setting->pkgname = strdup("pkgname");
+  setting->appid = strdup("appid");
+  setting->allow_to_display = 1;
+  EXPECT_CALL(GetMock<BadgeMock>(), badge_db_get_setting_by_appid(_, _, _))
+      .WillOnce(DoAll(SetArgPointee<1>(setting), Return(0)));
+  GVariant* param = g_variant_new("(si)", "appid", 5001);
+  GVariant* reply;
+  int ret = badge_get_setting_by_appid(param, &reply, 5001);
+  EXPECT_EQ(ret, BADGE_ERROR_NONE);
+
+  g_object_unref(param);
+  g_object_unref(reply);
+}
+
+TEST_F(BadgeServiceTest, badge_init_display) {
+  EXPECT_CALL(GetMock<BadgeMock>(), badge_db_get_list(_, _))
+      .WillOnce(Return(0));
+  GVariant* param = g_variant_new("(i)", 5001);
+  GVariant* reply;
+  int ret = badge_init_display(param, &reply, 5001);
+  EXPECT_EQ(ret, BADGE_ERROR_NONE);
+
+  g_object_unref(param);
+  g_object_unref(reply);
+}
\ No newline at end of file