Separate parser db handler and query db handler unit test

Change-Id: Idfa916390dfaf15aeb7ac6b0ee6ef70dc1b317a9
Signed-off-by: Junghyun Yeon <jungh.yeon@samsung.com>

diff --git a/test/unit_tests/test_parser_db_handlers.cc b/test/unit_tests/test_parser_db_handlers.cc
index 5ed0ccd..a1fcea3 100644 (file)
--- a/test/unit_tests/test_parser_db_handlers.cc
+++ b/test/unit_tests/test_parser_db_handlers.cc
@@ -27,7 +27,6 @@
 #include "parcel_utils.hh"
 #include "pkg_get_db_handler.hh"
 #include "pkg_set_db_handler.hh"
-#include "query_handler.hh"
 
 #include "mock/file_mock.h"
 #include "mock/test_fixture.h"
@@ -84,15 +83,6 @@ class DepInfoGetDBHandlerMock : public psd::DepInfoGetDBHandler {
   MOCK_METHOD0(GetConnection, std::vector<std::pair<sqlite3*, uid_t>>());
 };
 
-class QueryHandlerMock : public psd::QueryHandler {
- public:
-  QueryHandlerMock(uid_t uid, int pid) :
-      psd::QueryHandler(uid, pid) {}
-
-  MOCK_METHOD0(Connect, bool());
-  MOCK_METHOD0(GetConnection, std::vector<std::pair<sqlite3*, uid_t>>());
-};
-
 class Mocks : public ::testing::NiceMock<SystemInfoMock> {};
 
 class ParserDBHandlerTest : public TestFixture {
@@ -273,202 +263,3 @@ TEST_F(ParserDBHandlerTest, DepInfoDBHandlerTest) {
 
   EXPECT_TRUE(IsEqualDepInfo(depinfo_list, depinfo_from_db));
 }
-
-TEST_F(ParserDBHandlerTest, QueryDBHandler_PluginInfoTest) {
-  const std::string pkgid = "test_pkgid";
-  const std::string appid = "test_appid";
-  const std::string plugin_type = "test_plugin_type";
-  const std::string plugin_name = "test_plugin_name";
-
-  QueryHandlerMock set_query_handler(0, 0);
-  set_query_handler.SetQueryArgs(
-      std::vector<std::pair<int, std::vector<std::optional<std::string>>>>{
-          std::make_pair(
-              QUERY_INDEX_INSERT_PACKAGE_PLUGIN_EXECUTION_INFO,
-              std::vector<std::optional<std::string>>{
-                  pkgid, appid, plugin_type, plugin_name})});
-  set_query_handler.SetDBType(pkgmgr_common::DBType::DB_TYPE_FILE_PKGDB);
-  set_query_handler.SetOpType(
-      pkgmgr_common::DBOperationType::OPERATION_TYPE_WRITE);
-
-  EXPECT_CALL(set_query_handler,
-      Connect()).WillOnce(testing::Return(true));
-  EXPECT_CALL(set_query_handler, GetConnection())
-      .WillOnce(testing::Return(GetDBHandles()));
-  ASSERT_EQ(set_query_handler.Execute(), 0);
-
-  QueryHandlerMock get_query_handler(0, 0);
-  get_query_handler.SetQueryArgs(
-      std::vector<std::pair<int, std::vector<std::optional<std::string>>>>{
-          std::make_pair(
-              QUERY_INDEX_PLUGININFO_GET_APPIDS,
-              std::vector<std::optional<std::string>>{pkgid, plugin_type, plugin_name})});
-  get_query_handler.SetDBType(pkgmgr_common::DBType::DB_TYPE_FILE_PKGDB);
-  get_query_handler.SetOpType(
-      pkgmgr_common::DBOperationType::OPERATION_TYPE_READ);
-
-  EXPECT_CALL(get_query_handler,
-      Connect()).WillOnce(testing::Return(true));
-  EXPECT_CALL(get_query_handler, GetConnection())
-      .WillOnce(testing::Return(GetDBHandles()));
-  ASSERT_EQ(get_query_handler.Execute(), 0);
-  auto result = get_query_handler.GetResult();
-  ASSERT_EQ(result.size(), 1);
-  ASSERT_EQ(result[0].size(), 1);
-  ASSERT_EQ(appid, result[0][0]);
-}
-
-TEST_F(ParserDBHandlerTest, QueryDBHandler_GetLocaledLabelTest) {
-  PkgSetDBHandlerMock pkg_set_db_handler(0, 0);
-  pkg_set_db_handler.SetWriteType(pkgmgr_common::PkgWriteType::Insert);
-  std::unique_ptr<package_x, decltype(pkgmgrinfo_basic_free_package)*> ptr(
-      GetTestPackage("test_package"), pkgmgrinfo_basic_free_package);
-  pkg_set_db_handler.SetPkgInfo(ptr.get());
-
-  EXPECT_CALL(pkg_set_db_handler, Connect()).WillOnce(testing::Return(true));
-  EXPECT_CALL(pkg_set_db_handler, GetConnection())
-      .WillOnce(testing::Return(GetDBHandles()));
-  ASSERT_EQ(pkg_set_db_handler.Execute(), 0);
-
-  std::vector<std::pair<int, std::vector<std::optional<std::string>>>> query_args;
-  std::vector<std::vector<std::optional<std::string>>> expected_label;
-  for (GList* app_list = ptr.get()->application; app_list;
-      app_list = app_list->next) {
-    application_x* app = reinterpret_cast<application_x*>(app_list->data);
-    ASSERT_NE(app, nullptr);
-    ASSERT_NE(app->appid, nullptr);
-    ASSERT_NE(app->label, nullptr);
-
-    for (GList* label_list = app->label; label_list;
-        label_list = label_list->next) {
-      label_x* label = reinterpret_cast<label_x*>(label_list->data);
-      ASSERT_NE(label, nullptr);
-      ASSERT_NE(label->lang, nullptr);
-      ASSERT_NE(label->text, nullptr);
-      query_args.emplace_back(std::make_pair(
-          QUERY_INDEX_APPINFO_GET_LOCALED_LABEL,
-          std::vector<std::optional<std::string>>{app->appid, label->lang}));
-      expected_label.emplace_back(std::vector<std::optional<std::string>>{label->text});
-    }
-  }
-
-  QueryHandlerMock query_handler(0, 0);
-  query_handler.SetQueryArgs(std::move(query_args));
-  query_handler.SetDBType(pc::DBType::DB_TYPE_FILE_PKGDB);
-  query_handler.SetOpType(pc::DBOperationType::OPERATION_TYPE_READ);
-
-  EXPECT_CALL(query_handler,
-      Connect()).WillOnce(testing::Return(true));
-  EXPECT_CALL(query_handler, GetConnection())
-      .WillOnce(testing::Return(GetDBHandles()));
-  ASSERT_EQ(query_handler.Execute(), 0);
-  auto result = query_handler.GetResult();
-  ASSERT_EQ(result, expected_label);
-}
-
-TEST_F(ParserDBHandlerTest, QueryDBHandler_GetDataControlTest) {
-  PkgSetDBHandlerMock pkg_set_db_handler(0, 0);
-  pkg_set_db_handler.SetWriteType(pkgmgr_common::PkgWriteType::Insert);
-  std::unique_ptr<package_x, decltype(pkgmgrinfo_basic_free_package)*> ptr(
-      GetTestPackage("test_package"), pkgmgrinfo_basic_free_package);
-  pkg_set_db_handler.SetPkgInfo(ptr.get());
-
-  EXPECT_CALL(pkg_set_db_handler, Connect()).WillOnce(testing::Return(true));
-  EXPECT_CALL(pkg_set_db_handler, GetConnection())
-      .WillOnce(testing::Return(GetDBHandles()));
-  ASSERT_EQ(pkg_set_db_handler.Execute(), 0);
-
-  std::vector<std::pair<int, std::vector<std::optional<std::string>>>> query_args;
-  std::vector<std::vector<std::optional<std::string>>> expected_label;
-  for (GList* app_list = ptr.get()->application; app_list;
-      app_list = app_list->next) {
-    application_x* app = reinterpret_cast<application_x*>(app_list->data);
-    ASSERT_NE(app, nullptr);
-    ASSERT_NE(app->appid, nullptr);
-    ASSERT_NE(app->datacontrol, nullptr);
-
-    for (GList* dc_list = app->datacontrol; dc_list; dc_list = dc_list->next) {
-      datacontrol_x* dc = reinterpret_cast<datacontrol_x*>(dc_list->data);
-      ASSERT_NE(dc, nullptr);
-      ASSERT_NE(dc->providerid, nullptr);
-      ASSERT_NE(dc->type, nullptr);
-      ASSERT_NE(dc->access, nullptr);
-      query_args.emplace_back(std::make_pair(
-          QUERY_INDEX_APPINFO_GET_DATACONTROL_INFO,
-          std::vector<std::optional<std::string>>{dc->providerid, dc->type}));
-      expected_label.emplace_back(
-          std::vector<std::optional<std::string>>{app->appid, dc->access});
-    }
-  }
-
-  QueryHandlerMock query_handler(0, 0);
-  query_handler.SetQueryArgs(std::move(query_args));
-  query_handler.SetDBType(pc::DBType::DB_TYPE_FILE_PKGDB);
-  query_handler.SetOpType(pc::DBOperationType::OPERATION_TYPE_READ);
-
-  EXPECT_CALL(query_handler,
-      Connect()).WillOnce(testing::Return(true));
-  EXPECT_CALL(query_handler, GetConnection())
-      .WillOnce(testing::Return(GetDBHandles()));
-  ASSERT_EQ(query_handler.Execute(), 0);
-  auto result = query_handler.GetResult();
-  ASSERT_EQ(result, expected_label);
-}
-
-TEST_F(ParserDBHandlerTest, QueryDBHandler_GetDataControlAppIdTest) {
-  PkgSetDBHandlerMock pkg_set_db_handler(0, 0);
-  pkg_set_db_handler.SetWriteType(pkgmgr_common::PkgWriteType::Insert);
-  std::unique_ptr<package_x, decltype(pkgmgrinfo_basic_free_package)*> ptr(
-      GetTestPackage("test_package"), pkgmgrinfo_basic_free_package);
-  pkg_set_db_handler.SetPkgInfo(ptr.get());
-
-  EXPECT_CALL(pkg_set_db_handler, Connect()).WillOnce(testing::Return(true));
-  EXPECT_CALL(pkg_set_db_handler, GetConnection())
-      .WillOnce(testing::Return(GetDBHandles()));
-  ASSERT_EQ(pkg_set_db_handler.Execute(), 0);
-
-  std::vector<std::pair<int, std::vector<std::optional<std::string>>>> query_args;
-  std::vector<std::vector<std::optional<std::string>>> expected_appids;
-  std::map<std::string, std::vector<std::optional<std::string>>> provider_map;
-  for (GList* app_list = ptr.get()->application; app_list;
-      app_list = app_list->next) {
-    application_x* app = reinterpret_cast<application_x*>(app_list->data);
-    ASSERT_NE(app, nullptr);
-    ASSERT_NE(app->appid, nullptr);
-    ASSERT_NE(app->datacontrol, nullptr);
-
-    for (GList* dc_list = app->datacontrol; dc_list; dc_list = dc_list->next) {
-      datacontrol_x* dc = reinterpret_cast<datacontrol_x*>(dc_list->data);
-      ASSERT_NE(dc, nullptr);
-      ASSERT_NE(dc->providerid, nullptr);
-      ASSERT_NE(dc->type, nullptr);
-      ASSERT_NE(dc->access, nullptr);
-      provider_map[dc->providerid].emplace_back(app->appid);
-    }
-  }
-
-  for (auto& it : provider_map) {
-    query_args.emplace_back(std::make_pair(
-        QUERY_INDEX_APPINFO_GET_DATACONTROL_APPID,
-        std::vector<std::optional<std::string>>{std::move(it.first)}));
-    expected_appids.emplace_back(std::move(it.second));
-  }
-
-  QueryHandlerMock query_handler(0, 0);
-  query_handler.SetQueryArgs(std::move(query_args));
-  query_handler.SetDBType(pc::DBType::DB_TYPE_FILE_PKGDB);
-  query_handler.SetOpType(pc::DBOperationType::OPERATION_TYPE_READ);
-
-  EXPECT_CALL(query_handler,
-      Connect()).WillOnce(testing::Return(true));
-  EXPECT_CALL(query_handler, GetConnection())
-      .WillOnce(testing::Return(GetDBHandles()));
-  ASSERT_EQ(query_handler.Execute(), 0);
-  auto result = query_handler.GetResult();
-  ASSERT_NE(result.size(), 0);
-  for (auto& it : result)
-    std::sort(it.begin(), it.end());
-  for (auto& it : expected_appids)
-    std::sort(it.begin(), it.end());
-  ASSERT_EQ(result, expected_appids);
-}

diff --git a/test/unit_tests/test_query_db_handlers.cc b/test/unit_tests/test_query_db_handlers.cc
new file mode 100644 (file)
index 0000000..a87c21c
--- /dev/null
+++ b/test/unit_tests/test_query_db_handlers.cc
@@ -0,0 +1,316 @@
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gmock/gmock.h>
+
+#include <gtest/gtest.h>
+
+#include <cstdio>
+
+#include "create_db_handler.hh"
+#include "db_type.hh"
+#include "parcel_utils.hh"
+#include "pkg_set_db_handler.hh"
+#include "query_handler.hh"
+
+#include "mock/file_mock.h"
+#include "mock/test_fixture.h"
+#include "mock/system_info_mock.h"
+
+#include "pkgmgr-info.h"
+#include "pkgmgr_query_index.h"
+#include "pkgmgrinfo_basic.h"
+
+#define TEST_PARSER_DB "test.pkgmgr_parser.db"
+
+namespace psd = pkgmgr_server::database;
+namespace pc = pkgmgr_common;
+
+class CreateParserDBHandlerMock : public psd::CreateDBHandler {
+ public:
+  CreateParserDBHandlerMock(uid_t uid, int pid)
+      : psd::CreateDBHandler(uid, pid) {}
+
+  MOCK_METHOD0(Connect, bool());
+  MOCK_METHOD0(GetConnection, std::vector<std::pair<sqlite3*, uid_t>>());
+};
+
+class PkgSetDBHandlerMock : public psd::PkgSetDBHandler {
+ public:
+  PkgSetDBHandlerMock(uid_t uid, int pid) : psd::PkgSetDBHandler(uid, pid) {}
+
+  MOCK_METHOD0(Connect, bool());
+  MOCK_METHOD0(GetConnection, std::vector<std::pair<sqlite3*, uid_t>>());
+};
+
+class QueryHandlerMock : public psd::QueryHandler {
+ public:
+  QueryHandlerMock(uid_t uid, int pid) :
+      psd::QueryHandler(uid, pid) {}
+
+  MOCK_METHOD0(Connect, bool());
+  MOCK_METHOD0(GetConnection, std::vector<std::pair<sqlite3*, uid_t>>());
+};
+
+class Mocks : public ::testing::NiceMock<SystemInfoMock> {};
+
+class ParserDBHandlerTest : public TestFixture {
+ public:
+  ParserDBHandlerTest() : TestFixture(std::make_unique<Mocks>()) {}
+  virtual ~ParserDBHandlerTest() {}
+
+  virtual void SetUp() {
+    sqlite3 *db;
+    ASSERT_EQ(sqlite3_open_v2(TEST_PARSER_DB, &db,
+        SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL), SQLITE_OK);
+
+    SetDBHandles(
+        std::vector<std::pair<sqlite3*, uid_t>> { std::make_pair(db, 0) });
+    CreateParserDBHandlerMock create_db_handler(0, 0);
+
+    EXPECT_CALL(create_db_handler, Connect())
+        .Times(2).WillRepeatedly(testing::Return(true));
+    EXPECT_CALL(create_db_handler, GetConnection())
+        .Times(2).WillRepeatedly(testing::Return(GetDBHandles()));
+    EXPECT_CALL(GetMock<SystemInfoMock>(),
+      system_info_get_platform_int(testing::_, testing::_))
+          .WillRepeatedly(testing::DoAll(
+                  testing::SetArgPointee<1>(120), testing::Return(0)));
+    fopen_mock_setup(true);
+    ASSERT_EQ(create_db_handler.Execute(), 0);
+    fopen_mock_setup(false);
+  }
+
+  virtual void TearDown() {
+    for (auto& handle : db_handles_)
+      sqlite3_close_v2(handle.first);
+
+    ASSERT_EQ(remove(TEST_PARSER_DB), 0);
+    std::string journal_path(TEST_PARSER_DB);
+    journal_path += "-journal";
+    ASSERT_EQ(remove(journal_path.c_str()), 0);
+  }
+
+  const std::vector<std::pair<sqlite3*, uid_t>>& GetDBHandles() {
+    return db_handles_;
+  }
+
+ private:
+  void SetDBHandles(std::vector<std::pair<sqlite3*, uid_t>>&& db_handles) {
+    db_handles_ = db_handles;
+  }
+
+  std::vector<std::pair<sqlite3*, uid_t>> db_handles_;
+};
+
+TEST_F(ParserDBHandlerTest, QueryDBHandler_PluginInfoTest) {
+  const std::string pkgid = "test_pkgid";
+  const std::string appid = "test_appid";
+  const std::string plugin_type = "test_plugin_type";
+  const std::string plugin_name = "test_plugin_name";
+
+  QueryHandlerMock set_query_handler(0, 0);
+  set_query_handler.SetQueryArgs(
+      std::vector<std::pair<int, std::vector<std::optional<std::string>>>>{
+          std::make_pair(
+              QUERY_INDEX_INSERT_PACKAGE_PLUGIN_EXECUTION_INFO,
+              std::vector<std::optional<std::string>>{
+                  pkgid, appid, plugin_type, plugin_name})});
+  set_query_handler.SetDBType(pkgmgr_common::DBType::DB_TYPE_FILE_PKGDB);
+  set_query_handler.SetOpType(
+      pkgmgr_common::DBOperationType::OPERATION_TYPE_WRITE);
+
+  EXPECT_CALL(set_query_handler,
+      Connect()).WillOnce(testing::Return(true));
+  EXPECT_CALL(set_query_handler, GetConnection())
+      .WillOnce(testing::Return(GetDBHandles()));
+  ASSERT_EQ(set_query_handler.Execute(), 0);
+
+  QueryHandlerMock get_query_handler(0, 0);
+  get_query_handler.SetQueryArgs(
+      std::vector<std::pair<int, std::vector<std::optional<std::string>>>>{
+          std::make_pair(
+              QUERY_INDEX_PLUGININFO_GET_APPIDS,
+              std::vector<std::optional<std::string>>{pkgid, plugin_type, plugin_name})});
+  get_query_handler.SetDBType(pkgmgr_common::DBType::DB_TYPE_FILE_PKGDB);
+  get_query_handler.SetOpType(
+      pkgmgr_common::DBOperationType::OPERATION_TYPE_READ);
+
+  EXPECT_CALL(get_query_handler,
+      Connect()).WillOnce(testing::Return(true));
+  EXPECT_CALL(get_query_handler, GetConnection())
+      .WillOnce(testing::Return(GetDBHandles()));
+  ASSERT_EQ(get_query_handler.Execute(), 0);
+  auto result = get_query_handler.GetResult();
+  ASSERT_EQ(result.size(), 1);
+  ASSERT_EQ(result[0].size(), 1);
+  ASSERT_EQ(appid, result[0][0]);
+}
+
+TEST_F(ParserDBHandlerTest, QueryDBHandler_GetLocaledLabelTest) {
+  PkgSetDBHandlerMock pkg_set_db_handler(0, 0);
+  pkg_set_db_handler.SetWriteType(pkgmgr_common::PkgWriteType::Insert);
+  std::unique_ptr<package_x, decltype(pkgmgrinfo_basic_free_package)*> ptr(
+      GetTestPackage("test_package"), pkgmgrinfo_basic_free_package);
+  pkg_set_db_handler.SetPkgInfo(ptr.get());
+
+  EXPECT_CALL(pkg_set_db_handler, Connect()).WillOnce(testing::Return(true));
+  EXPECT_CALL(pkg_set_db_handler, GetConnection())
+      .WillOnce(testing::Return(GetDBHandles()));
+  ASSERT_EQ(pkg_set_db_handler.Execute(), 0);
+
+  std::vector<std::pair<int, std::vector<std::optional<std::string>>>> query_args;
+  std::vector<std::vector<std::optional<std::string>>> expected_label;
+  for (GList* app_list = ptr.get()->application; app_list;
+      app_list = app_list->next) {
+    application_x* app = reinterpret_cast<application_x*>(app_list->data);
+    ASSERT_NE(app, nullptr);
+    ASSERT_NE(app->appid, nullptr);
+    ASSERT_NE(app->label, nullptr);
+
+    for (GList* label_list = app->label; label_list;
+        label_list = label_list->next) {
+      label_x* label = reinterpret_cast<label_x*>(label_list->data);
+      ASSERT_NE(label, nullptr);
+      ASSERT_NE(label->lang, nullptr);
+      ASSERT_NE(label->text, nullptr);
+      query_args.emplace_back(std::make_pair(
+          QUERY_INDEX_APPINFO_GET_LOCALED_LABEL,
+          std::vector<std::optional<std::string>>{app->appid, label->lang}));
+      expected_label.emplace_back(std::vector<std::optional<std::string>>{label->text});
+    }
+  }
+
+  QueryHandlerMock query_handler(0, 0);
+  query_handler.SetQueryArgs(std::move(query_args));
+  query_handler.SetDBType(pc::DBType::DB_TYPE_FILE_PKGDB);
+  query_handler.SetOpType(pc::DBOperationType::OPERATION_TYPE_READ);
+
+  EXPECT_CALL(query_handler,
+      Connect()).WillOnce(testing::Return(true));
+  EXPECT_CALL(query_handler, GetConnection())
+      .WillOnce(testing::Return(GetDBHandles()));
+  ASSERT_EQ(query_handler.Execute(), 0);
+  auto result = query_handler.GetResult();
+  ASSERT_EQ(result, expected_label);
+}
+
+TEST_F(ParserDBHandlerTest, QueryDBHandler_GetDataControlTest) {
+  PkgSetDBHandlerMock pkg_set_db_handler(0, 0);
+  pkg_set_db_handler.SetWriteType(pkgmgr_common::PkgWriteType::Insert);
+  std::unique_ptr<package_x, decltype(pkgmgrinfo_basic_free_package)*> ptr(
+      GetTestPackage("test_package"), pkgmgrinfo_basic_free_package);
+  pkg_set_db_handler.SetPkgInfo(ptr.get());
+
+  EXPECT_CALL(pkg_set_db_handler, Connect()).WillOnce(testing::Return(true));
+  EXPECT_CALL(pkg_set_db_handler, GetConnection())
+      .WillOnce(testing::Return(GetDBHandles()));
+  ASSERT_EQ(pkg_set_db_handler.Execute(), 0);
+
+  std::vector<std::pair<int, std::vector<std::optional<std::string>>>> query_args;
+  std::vector<std::vector<std::optional<std::string>>> expected_label;
+  for (GList* app_list = ptr.get()->application; app_list;
+      app_list = app_list->next) {
+    application_x* app = reinterpret_cast<application_x*>(app_list->data);
+    ASSERT_NE(app, nullptr);
+    ASSERT_NE(app->appid, nullptr);
+    ASSERT_NE(app->datacontrol, nullptr);
+
+    for (GList* dc_list = app->datacontrol; dc_list; dc_list = dc_list->next) {
+      datacontrol_x* dc = reinterpret_cast<datacontrol_x*>(dc_list->data);
+      ASSERT_NE(dc, nullptr);
+      ASSERT_NE(dc->providerid, nullptr);
+      ASSERT_NE(dc->type, nullptr);
+      ASSERT_NE(dc->access, nullptr);
+      query_args.emplace_back(std::make_pair(
+          QUERY_INDEX_APPINFO_GET_DATACONTROL_INFO,
+          std::vector<std::optional<std::string>>{dc->providerid, dc->type}));
+      expected_label.emplace_back(
+          std::vector<std::optional<std::string>>{app->appid, dc->access});
+    }
+  }
+
+  QueryHandlerMock query_handler(0, 0);
+  query_handler.SetQueryArgs(std::move(query_args));
+  query_handler.SetDBType(pc::DBType::DB_TYPE_FILE_PKGDB);
+  query_handler.SetOpType(pc::DBOperationType::OPERATION_TYPE_READ);
+
+  EXPECT_CALL(query_handler,
+      Connect()).WillOnce(testing::Return(true));
+  EXPECT_CALL(query_handler, GetConnection())
+      .WillOnce(testing::Return(GetDBHandles()));
+  ASSERT_EQ(query_handler.Execute(), 0);
+  auto result = query_handler.GetResult();
+  ASSERT_EQ(result, expected_label);
+}
+
+TEST_F(ParserDBHandlerTest, QueryDBHandler_GetDataControlAppIdTest) {
+  PkgSetDBHandlerMock pkg_set_db_handler(0, 0);
+  pkg_set_db_handler.SetWriteType(pkgmgr_common::PkgWriteType::Insert);
+  std::unique_ptr<package_x, decltype(pkgmgrinfo_basic_free_package)*> ptr(
+      GetTestPackage("test_package"), pkgmgrinfo_basic_free_package);
+  pkg_set_db_handler.SetPkgInfo(ptr.get());
+
+  EXPECT_CALL(pkg_set_db_handler, Connect()).WillOnce(testing::Return(true));
+  EXPECT_CALL(pkg_set_db_handler, GetConnection())
+      .WillOnce(testing::Return(GetDBHandles()));
+  ASSERT_EQ(pkg_set_db_handler.Execute(), 0);
+
+  std::vector<std::pair<int, std::vector<std::optional<std::string>>>> query_args;
+  std::vector<std::vector<std::optional<std::string>>> expected_appids;
+  std::map<std::string, std::vector<std::optional<std::string>>> provider_map;
+  for (GList* app_list = ptr.get()->application; app_list;
+      app_list = app_list->next) {
+    application_x* app = reinterpret_cast<application_x*>(app_list->data);
+    ASSERT_NE(app, nullptr);
+    ASSERT_NE(app->appid, nullptr);
+    ASSERT_NE(app->datacontrol, nullptr);
+
+    for (GList* dc_list = app->datacontrol; dc_list; dc_list = dc_list->next) {
+      datacontrol_x* dc = reinterpret_cast<datacontrol_x*>(dc_list->data);
+      ASSERT_NE(dc, nullptr);
+      ASSERT_NE(dc->providerid, nullptr);
+      ASSERT_NE(dc->type, nullptr);
+      ASSERT_NE(dc->access, nullptr);
+      provider_map[dc->providerid].emplace_back(app->appid);
+    }
+  }
+
+  for (auto& it : provider_map) {
+    query_args.emplace_back(std::make_pair(
+        QUERY_INDEX_APPINFO_GET_DATACONTROL_APPID,
+        std::vector<std::optional<std::string>>{std::move(it.first)}));
+    expected_appids.emplace_back(std::move(it.second));
+  }
+
+  QueryHandlerMock query_handler(0, 0);
+  query_handler.SetQueryArgs(std::move(query_args));
+  query_handler.SetDBType(pc::DBType::DB_TYPE_FILE_PKGDB);
+  query_handler.SetOpType(pc::DBOperationType::OPERATION_TYPE_READ);
+
+  EXPECT_CALL(query_handler,
+      Connect()).WillOnce(testing::Return(true));
+  EXPECT_CALL(query_handler, GetConnection())
+      .WillOnce(testing::Return(GetDBHandles()));
+  ASSERT_EQ(query_handler.Execute(), 0);
+  auto result = query_handler.GetResult();
+  ASSERT_NE(result.size(), 0);
+  for (auto& it : result)
+    std::sort(it.begin(), it.end());
+  for (auto& it : expected_appids)
+    std::sort(it.begin(), it.end());
+  ASSERT_EQ(result, expected_appids);
+}