Add DBus Service Test

Change-Id: Ib256e1b1046e8647f4bbc9362752a627368bdd05

diff --git a/src/unit_tests/dbus_service_test.cc b/src/unit_tests/dbus_service_test.cc
new file mode 100644 (file)
index 0000000..83de988
--- /dev/null
+++ b/src/unit_tests/dbus_service_test.cc
@@ -0,0 +1,232 @@
+// Copyright (c) 2019 Samsung Electronics Co., Ltd All Rights Reserved\r
+// Use of this source code is governed by a apache 2.0 license that can be\r
+// found in the LICENSE file.\r
+\r
+#include <gmock/gmock.h>\r
+#include <glib.h>\r
+#include <glib/gstdio.h>\r
+#include <sys/types.h>\r
+#include <sys/stat.h>\r
+#include <fcntl.h>\r
+#include <bundle.h>\r
+\r
+#include <iostream>\r
+#include <fstream>\r
+\r
+#include "mock/gio.h"\r
+#include "mock/cynara-creds-gdbus.h"\r
+\r
+#include "common/dbus_service.h"\r
+\r
+namespace capmgr {\r
+void (*__method_handler)(GDBusConnection* connection, const gchar* sender,\r
+    const gchar* object_path, const gchar* interface_name,\r
+    const gchar* method_name, GVariant* parameters,\r
+    GDBusMethodInvocation* invocation, gpointer user_data);\r
+\r
+gpointer __method_handler_data;\r
+GDBusConnection* __method_handler_conn;\r
+\r
+guint __g_bus_own_name_fake(GBusType bus_type, const gchar* name,\r
+    GBusNameOwnerFlags flags, GBusAcquiredCallback bus_acquired_handler,\r
+    GBusNameAcquiredCallback name_acquired_handler,\r
+    GBusNameLostCallback name_lost_handler, gpointer user_data,\r
+    GDestroyNotify user_data_free_func) {\r
+\r
+  GDBusConnection* conn = reinterpret_cast<GDBusConnection*>(g_object_new(\r
+      G_TYPE_OBJECT, nullptr));\r
+\r
+  bus_acquired_handler(conn, "fakeconn", user_data);\r
+\r
+  return 999;\r
+}\r
+\r
+guint __g_dbus_connection_register_object_fake(GDBusConnection* connection,\r
+    const gchar* object_path, GDBusInterfaceInfo* interface_info,\r
+    const GDBusInterfaceVTable* vtable, gpointer user_data,\r
+    GDestroyNotify user_data_free_func, GError** error) {\r
+  __method_handler = vtable->method_call;\r
+  __method_handler_conn = connection;\r
+  __method_handler_data = user_data;\r
+  return 999;\r
+}\r
+\r
+class DBusServiceTest : public ::testing::Test {\r
+ protected:\r
+  void SetUp() override {\r
+    g_bus_own_name_fake.custom_fake = __g_bus_own_name_fake;\r
+    g_dbus_connection_register_object_fake.custom_fake =\r
+        __g_dbus_connection_register_object_fake;\r
+  }\r
+\r
+  void TearDown() override {\r
+  }\r
+\r
+  void PushMethodHandler(const gchar* method_name, GVariant* parameters) {\r
+    GDBusMethodInvocation* fake_invoc = reinterpret_cast<GDBusMethodInvocation*>\r
+        (g_object_new(G_TYPE_OBJECT, nullptr));\r
+    __method_handler(__method_handler_conn, "1.3", "/org/tizen/capmgr",\r
+        "org.tizen.capmgr", method_name, parameters, fake_invoc,\r
+        __method_handler_data);\r
+  }\r
+};\r
+\r
+TEST_F(DBusServiceTest, MethodTest) {\r
+  int call_count = 0;\r
+  DBusService service = DBusService();\r
+\r
+  service.RegisterMethodHandler("DiscoverUnownedDevices", [&call_count]() {\r
+    call_count++;\r
+  });\r
+  PushMethodHandler("DiscoverUnownedDevices", nullptr);\r
+\r
+  service.RegisterMethodHandler("ExchangeCapabilities", [&call_count]() {\r
+    call_count++;\r
+  });\r
+  PushMethodHandler("ExchangeCapabilities", nullptr);\r
+\r
+  ASSERT_EQ(call_count, 2);\r
+}\r
+\r
+void __bundle_to_gvar_arr(bundle* b, GVariantBuilder** arr, guint* arr_len) {\r
+  GVariantBuilder* array_builder;\r
+  bundle_raw* raw;\r
+  int len;\r
+  bundle_encode(b, &raw, &len);\r
+  *arr_len = len;\r
+  array_builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));\r
+  for (int i = 0; i < len; i++)\r
+    g_variant_builder_add(array_builder, "y", raw[i]);\r
+\r
+  *arr = array_builder;\r
+  free(raw);\r
+}\r
+\r
+void __gvar_arr_to_cstr(GVariantIter* gvar_iter, guint len, char** str) {\r
+  guchar* arr = reinterpret_cast<guchar*>(g_try_malloc(len));\r
+  for (unsigned int i = 0; i < len; i++) {\r
+    g_variant_iter_loop(gvar_iter, "y", &arr[i]);\r
+  }\r
+\r
+  *str = reinterpret_cast<char*>(arr);\r
+}\r
+\r
+TEST_F(DBusServiceTest, SendAppControlTest) {\r
+  DBusService service = DBusService();\r
+  char *val;\r
+  std::string* dev_id;\r
+\r
+  service.RegisterSendAppcontrolHandler("SendRemoteAppControl",\r
+      [&val, &dev_id](const std::string& device_id, const unsigned char* data,\r
+      size_t len) {\r
+    bundle* b;\r
+    char *b_val;\r
+    dev_id = new std::string(device_id);\r
+    b = bundle_decode(data, len);\r
+    bundle_get_str(b, "test", &b_val);\r
+    val = strdup(b_val);\r
+    bundle_free(b);\r
+    return 777;\r
+  });\r
+\r
+  bundle* b = bundle_create();\r
+  bundle_add_str(b, "test", "1234");\r
+  GVariantBuilder* array_builder;\r
+  guint array_len;\r
+  __bundle_to_gvar_arr(b, &array_builder, &array_len);\r
+  bundle_free(b);\r
+\r
+  GVariant* appcontrol_var = g_variant_new("(&sayu)", "testdevice",\r
+      array_builder, array_len);\r
+  g_variant_builder_unref(array_builder);\r
+  PushMethodHandler("SendRemoteAppControl", appcontrol_var);\r
+  g_variant_unref(appcontrol_var);\r
+\r
+  ASSERT_THAT(*dev_id, testing::StrEq("testdevice"));\r
+  ASSERT_THAT(val, testing::StrEq("1234"));\r
+\r
+  const char* test_str = "test-string-1234";\r
+  RESET_FAKE(g_dbus_method_invocation_return_value);\r
+  service.SendAppControlReply(777,\r
+      reinterpret_cast<const unsigned char*>(test_str), strlen(test_str) + 1);\r
+\r
+  GVariant* reply = g_dbus_method_invocation_return_value_fake.arg1_history[0];\r
+  GVariantIter* reply_iter;\r
+  guint reply_len;\r
+  g_variant_get(reply, "(ayu)", &reply_iter, &reply_len);\r
+\r
+  char* reply_str;\r
+  __gvar_arr_to_cstr(reply_iter, reply_len, &reply_str);\r
+  g_variant_iter_free(reply_iter);\r
+\r
+  ASSERT_EQ(g_strcmp0(reply_str, test_str), 0);\r
+  g_free(reply_str);\r
+  free(val);\r
+  delete dev_id;\r
+}\r
+\r
+int __fake_creds_gdbus_get_client(GDBusConnection* conn,\r
+    const gchar* sender, enum cynara_client_creds type, gchar** client) {\r
+  *client = strdup("testclient");\r
+  return 0;\r
+}\r
+\r
+int __fake_creds_gdbus_get_user(GDBusConnection* conn,\r
+    const gchar* sender, enum cynara_user_creds type, gchar** user) {\r
+  *user = strdup("testuser");\r
+  return 0;\r
+}\r
+\r
+int __fake_creds_gdbus_get_pid(GDBusConnection* conn,\r
+    const gchar* sender, pid_t* pid) {\r
+  *pid = 999;\r
+  return 0;\r
+}\r
+\r
+TEST_F(DBusServiceTest, SendFileTest) {\r
+  cynara_creds_gdbus_get_client_fake.custom_fake =\r
+      __fake_creds_gdbus_get_client;\r
+  cynara_creds_gdbus_get_user_fake.custom_fake = __fake_creds_gdbus_get_user;\r
+  cynara_creds_gdbus_get_pid_fake.custom_fake = __fake_creds_gdbus_get_pid;\r
+\r
+  DBusService service = DBusService();\r
+  int call_count = 0;\r
+  service.RegisterSendFileHandler("SendFile", [&call_count] (\r
+      const std::string& device_id, const std::string& path) {\r
+    int rval = 777;\r
+    call_count++;\r
+    return rval;\r
+  });\r
+\r
+  std::ofstream outfile("../../.capmgr_test");\r
+  outfile << " " << std::endl;\r
+  outfile.close();\r
+  GVariant* req = g_variant_new("(ss)", "test_device_id", "../../.capmgr_test");\r
+  PushMethodHandler("SendFile", req);\r
+  g_variant_unref(req);\r
+  ASSERT_THAT(call_count, testing::Eq(1));\r
+\r
+  RESET_FAKE(g_dbus_connection_emit_signal);\r
+  for (int i = 0; i < 10; i++) {\r
+    long long stored_sent;  // NOLINT\r
+    long long stored_total;  // NOLINT\r
+    gchar* stored_path;\r
+    service.SendFileProgress("../../.capmgr_test", i + 1, 10);\r
+    ASSERT_EQ(g_strcmp0(g_dbus_connection_emit_signal_fake.arg4_history[i],\r
+        "SendFileProgressChanged"), 0);\r
+    g_variant_get(g_dbus_connection_emit_signal_fake.arg5_history[i], "(sxx)",\r
+        &stored_path, &stored_sent, &stored_total);\r
+    ASSERT_EQ(g_strcmp0(stored_path, "../../.capmgr_test"), 0);\r
+    ASSERT_THAT(stored_sent, testing::Eq(i + 1));\r
+    ASSERT_THAT(stored_total, testing::Eq(10));\r
+  }\r
+\r
+  RESET_FAKE(g_dbus_method_invocation_return_value);\r
+  service.SendFileResult("../../.capmgr_test", 0);\r
+  int result;\r
+  g_variant_get(g_dbus_method_invocation_return_value_fake.arg1_history[0],\r
+      "(i)", &result);\r
+  ASSERT_THAT(result, testing::Eq(0));\r
+}\r
+\r
+}  // namespace capmgr\r

diff --git a/src/unit_tests/mock/aul.h b/src/unit_tests/mock/aul.h
index 69367dfa2f908576219213dbe379b0d7c908dc77..e427237ccf23bba2ff99d5c60ef4569f0f8d1e5c 100644 (file)
--- a/src/unit_tests/mock/aul.h
+++ b/src/unit_tests/mock/aul.h
@@ -5,40 +5,9 @@
 #ifndef MOCK_AUL_H_
 #define MOCK_AUL_H_
 
-#include "mock.h"
-#include "bundle.h"
-
-typedef enum _aul_return_val {
-  AUL_R_ENOENT = -15,
-  AUL_R_EREJECTED = -14,
-  AUL_R_ENOAPP = -13,
-  AUL_R_EHIDDENFORGUEST = -11,
-  AUL_R_ENOLAUNCHPAD = -10,
-  AUL_R_ETERMINATING = -9,
-  AUL_R_EILLACC = -8,
-  AUL_R_LOCAL = -7,
-  AUL_R_ETIMEOUT = -6,
-  AUL_R_ECANCELED = -5,
-  AUL_R_EINVAL = -4,
-  AUL_R_ECOMM = -3,
-  AUL_R_ENOINIT = -2,
-  AUL_R_ERROR = -1,
-  AUL_R_OK = 0
-} aul_return_val;
+#include <aul.h>
 
-typedef enum _aul_type {
-  AUL_START,
-  AUL_RESUME,
-  AUL_TERMINATE,
-  AUL_TERMINATE_BGAPP,
-  AUL_PAUSE,
-  AUL_WAKE,
-  AUL_SUSPEND,
-  AUL_WIDGET_CONTENT,
-  AUL_UPDATE_REQUESTED,
-} aul_type;
-
-typedef int (*aul_handler_fn)(aul_type type, bundle *b, void *data);
+#include "mock.h"
 
 DECLARE_FAKE_VALUE_FUNC(int, aul_launch_init, aul_handler_fn, void*);
 

diff --git a/src/unit_tests/mock/aul_svc.h b/src/unit_tests/mock/aul_svc.h
index 01ec01c435d47a0ac832a60f42e85668885fe2c2..992ded743849652a74cad1dfd6771b9b65203eaf 100644 (file)
--- a/src/unit_tests/mock/aul_svc.h
+++ b/src/unit_tests/mock/aul_svc.h
@@ -5,30 +5,8 @@
 #ifndef MOCK_AUL_SVC_H_
 #define MOCK_AUL_SVC_H_
 
-#include <sys/types.h>
+#include <aul_svc.h>
 #include "mock.h"
-#include "bundle.h"
-
-typedef enum _aul_svc_return_val {
-  AUL_SVC_RET_ECANCELED = -8,  /**< Operation is canceled */
-  AUL_SVC_RET_EREJECTED = -7,  /**< application launch rejected */
-  AUL_SVC_RET_ETERMINATING = -6,   /**< application terminating */
-  AUL_SVC_RET_EILLACC = -5,        /**< Illegal Access */
-  AUL_SVC_RET_ELAUNCH = -4,        /**< Failure on launching the app */
-  AUL_SVC_RET_ENOMATCH = -3,       /**< No matching result Error */
-  AUL_SVC_RET_EINVAL = -2,         /**< Invalid argument */
-  AUL_SVC_RET_ERROR = -1,          /**< General error */
-  AUL_SVC_RET_OK = 0           /**< General success */
-} aul_svc_return_val;
-
-typedef enum _aul_svc_result_val {
-  AUL_SVC_RES_CANCEL = -2,     /**< Cancel by system */
-  AUL_SVC_RES_NOT_OK = -1,     /**< Fail by user */
-  AUL_SVC_RES_OK = 0       /**< Success by user */
-} aul_svc_result_val;
-
-typedef void (*aul_svc_res_fn)(bundle *b, int request_code,
-    aul_svc_result_val result, void *data);
 
 DECLARE_FAKE_VALUE_FUNC(const char*, aul_svc_get_appid, bundle*);
 DECLARE_FAKE_VALUE_FUNC(int, aul_svc_run_service_async_for_uid, bundle*, int,

diff --git a/src/unit_tests/mock/bundle.cc b/src/unit_tests/mock/bundle.cc
deleted file mode 100644 (file)
index d461c09..0000000
--- a/src/unit_tests/mock/bundle.cc
+++ /dev/null
@@ -1,17 +0,0 @@
-// Copyright (c) 2019 Samsung Electronics Co., Ltd All Rights Reserved
-// Use of this source code is governed by a apache 2.0 license that can be
-// found in the LICENSE file.
-
-#include "bundle.h"  // NOLINT(build/include)
-
-int bundle_encode(bundle* b, bundle_raw** raw, int* len) {
-  return 0;
-}
-
-bundle* bundle_decode(const bundle_raw* raw, const int len) {
-  return nullptr;
-}
-
-int bundle_free(bundle* b) {
-  return 0;
-}

diff --git a/src/unit_tests/mock/bundle.h b/src/unit_tests/mock/bundle.h
deleted file mode 100644 (file)
index bcadee0..0000000
--- a/src/unit_tests/mock/bundle.h
+++ /dev/null
@@ -1,24 +0,0 @@
-// Copyright (c) 2019 Samsung Electronics Co., Ltd All Rights Reserved
-// Use of this source code is governed by a apache 2.0 license that can be
-// found in the LICENSE file.
-
-#ifndef MOCK_BUNDLE_H_
-#define MOCK_BUNDLE_H_
-
-typedef enum {
-  BUNDLE_ERROR_NONE, /**< Successful */
-  BUNDLE_ERROR_OUT_OF_MEMORY, /**< Out of memory */
-  BUNDLE_ERROR_INVALID_PARAMETER, /**< Invalid parameter */
-  BUNDLE_ERROR_KEY_NOT_AVAILABLE, /**< Required key not available */
-  BUNDLE_ERROR_KEY_EXISTS /**< Key exists */
-} bundle_error_e;
-
-typedef struct _bundle_t bundle;
-
-typedef unsigned char bundle_raw;
-
-int bundle_encode(bundle* b, bundle_raw** raw, int* len);
-bundle* bundle_decode(const bundle_raw* raw, const int len);
-int bundle_free(bundle* b);
-
-#endif  // MOCK_BUNDLE_H_

diff --git a/src/unit_tests/mock/cynara-creds-gdbus.h b/src/unit_tests/mock/cynara-creds-gdbus.h
index 1851fa056691d42a6efa30fd3e8155445de42242..e181d8d5fb6795ff2030399ec3a0ef95ecd50e55 100644 (file)
--- a/src/unit_tests/mock/cynara-creds-gdbus.h
+++ b/src/unit_tests/mock/cynara-creds-gdbus.h
@@ -6,25 +6,9 @@
 #define MOCK_CYNARA_CREDS_DBUS_H_
 
 #include <gio/gio.h>
-
+#include <cynara-creds-gdbus.h>
 #include "mock.h"
 
-#define CYNARA_API_SUCCESS                      0
-
-enum cynara_client_creds {
-  CLIENT_METHOD_SMACK,
-  CLIENT_METHOD_PID,
-
-  CLIENT_METHOD_DEFAULT = 0xFFFF,
-};
-
-enum cynara_user_creds {
-  USER_METHOD_UID,
-  USER_METHOD_GID,
-
-  USER_METHOD_DEFAULT = 0xFFFF,
-};
-
 DECLARE_FAKE_VALUE_FUNC(int, cynara_creds_gdbus_get_client, GDBusConnection*,
     const gchar*, enum cynara_client_creds, gchar**);
 DECLARE_FAKE_VALUE_FUNC(int, cynara_creds_gdbus_get_user, GDBusConnection*,

diff --git a/src/unit_tests/mock/gio.h b/src/unit_tests/mock/gio.h
new file mode 100644 (file)
index 0000000..e17044e
--- /dev/null
+++ b/src/unit_tests/mock/gio.h
@@ -0,0 +1,24 @@
+#include "mock.h"\r
+\r
+#include <glib.h>\r
+#include <gio/gio.h>\r
+\r
+DECLARE_FAKE_VALUE_FUNC(guint, g_bus_own_name, GBusType, const gchar*,\r
+    GBusNameOwnerFlags, GBusAcquiredCallback, GBusNameAcquiredCallback,\r
+    GBusNameLostCallback, gpointer, GDestroyNotify);\r
+\r
+DECLARE_FAKE_VALUE_FUNC(guint, g_dbus_connection_register_object,\r
+    GDBusConnection*, const gchar*, GDBusInterfaceInfo*,\r
+    const GDBusInterfaceVTable*, gpointer, GDestroyNotify, GError**);\r
+\r
+DECLARE_FAKE_VOID_FUNC(g_dbus_method_invocation_return_value,\r
+    GDBusMethodInvocation*, GVariant*);\r
+\r
+DECLARE_FAKE_VOID_FUNC(g_bus_unown_name, guint);\r
+\r
+DECLARE_FAKE_VALUE_FUNC(gboolean, g_dbus_connection_emit_signal,\r
+    GDBusConnection*, const gchar*, const gchar*, const gchar*, const gchar*,\r
+    GVariant*, GError**);\r
+\r
+DECLARE_FAKE_VALUE_FUNC(gboolean, g_dbus_connection_flush_sync,\r
+    GDBusConnection*, GCancellable*, GError**);
\ No newline at end of file

diff --git a/src/unit_tests/mock/mock.cc b/src/unit_tests/mock/mock.cc
index b21ede9ecb078ba7949691fe54fc1f3cf911bf97..fe5cc5b7b1bb2caa38f5cc7430fd0fca17a430f1 100644 (file)
--- a/src/unit_tests/mock/mock.cc
+++ b/src/unit_tests/mock/mock.cc
@@ -5,6 +5,7 @@
 #include "aul.h"   // NOLINT(build/include)
 #include "aul_svc.h"  // NOLINT(build/include)
 #include "cynara-creds-gdbus.h"  // NOLINT(build/include)
+#include "gio.h"  // NOLINT(build/include)
 #include "mdg.h"  // NOLINT(build/include)
 #include "mdg_internal.h"  // NOLINT(build/include)
 #include "mock.h"  // NOLINT(build/include)
@@ -99,3 +100,19 @@ DEFINE_FAKE_VALUE_FUNC(int, cynara_creds_gdbus_get_user, GDBusConnection*,
     const gchar*, enum cynara_user_creds, gchar**);
 DEFINE_FAKE_VALUE_FUNC(int, cynara_creds_gdbus_get_pid, GDBusConnection*,
     const gchar*, pid_t*);
+
+/* gio.h */
+DEFINE_FAKE_VALUE_FUNC(guint, g_bus_own_name, GBusType, const gchar*,
+    GBusNameOwnerFlags, GBusAcquiredCallback, GBusNameAcquiredCallback,
+    GBusNameLostCallback, gpointer, GDestroyNotify);
+DEFINE_FAKE_VALUE_FUNC(guint, g_dbus_connection_register_object,
+    GDBusConnection*, const gchar*, GDBusInterfaceInfo*,
+    const GDBusInterfaceVTable*, gpointer, GDestroyNotify, GError**);
+DEFINE_FAKE_VOID_FUNC(g_dbus_method_invocation_return_value,
+    GDBusMethodInvocation*, GVariant*);
+DEFINE_FAKE_VOID_FUNC(g_bus_unown_name, guint);
+DEFINE_FAKE_VALUE_FUNC(gboolean, g_dbus_connection_emit_signal,
+    GDBusConnection*, const gchar*, const gchar*, const gchar*, const gchar*,
+    GVariant*, GError**);
+DEFINE_FAKE_VALUE_FUNC(gboolean, g_dbus_connection_flush_sync,
+    GDBusConnection*, GCancellable*, GError**);

diff --git a/src/unit_tests/package_manager_test.cc b/src/unit_tests/package_manager_test.cc
index cacb73a282978b13c5a71c89a0d926ea8ec08c48..2b458d7b091ddf6c20d37097594af4067055e3ca 100644 (file)
--- a/src/unit_tests/package_manager_test.cc
+++ b/src/unit_tests/package_manager_test.cc
@@ -23,12 +23,12 @@ TEST_F(PackageManagerTest, RemotePackageInfoTest) {
   std::vector<std::string> applist = {"org.tizen.appid1", "org.tizen.appid2"};\r
   capmgr::RemotePackageInfo rpi = capmgr::RemotePackageInfo("org.tizen.package",\r
       "label", "version", applist);\r
+\r
   ASSERT_THAT(rpi.pkgid(), testing::Eq("org.tizen.package"));\r
   ASSERT_THAT(rpi.label(), testing::Eq("label"));\r
   ASSERT_THAT(rpi.version(), testing::Eq("version"));\r
   ASSERT_THAT(rpi.appids()[0], testing::Eq("org.tizen.appid1"));\r
   ASSERT_THAT(rpi.appids()[1], testing::Eq("org.tizen.appid2"));\r
-\r
   Json::StreamWriterBuilder json_builder;\r
   Json::Value json;\r
   json["appids"] = Json::Value(Json::arrayValue);\r
@@ -37,7 +37,6 @@ TEST_F(PackageManagerTest, RemotePackageInfoTest) {
   json["pkgid"] = "org.tizen.package";\r
   json["label"] = "label";\r
   json["version"] = "version";\r
-\r
   capmgr::RemotePackageInfo rpijson = capmgr::RemotePackageInfo(\r
       Json::writeString(json_builder, json));\r
   ASSERT_THAT(rpi.Serialize(), testing::Eq(rpijson.Serialize()));\r