--- /dev/null
- std::vector<std::pair<int, std::vector<std::string>>>{
+ /*
+ * 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 "appinfo_db_handler.hh"
+ #include "create_db_handler.hh"
+ #include "depinfo_db_handler.hh"
+ #include "db_type.hh"
+ #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"
+ #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 PkgGetDBHandlerMock : public psd::PkgGetDBHandler {
+ public:
+ PkgGetDBHandlerMock(uid_t uid, int pid) : psd::PkgGetDBHandler(uid, pid) {}
+
+ MOCK_METHOD0(Connect, bool());
+ MOCK_METHOD0(GetConnection, std::vector<std::pair<sqlite3*, uid_t>>());
+ };
+
+ class AppInfoDBHandlerMock : public psd::AppInfoDBHandler {
+ public:
+ AppInfoDBHandlerMock(uid_t uid, int pid) : psd::AppInfoDBHandler(uid, pid) {}
+
+ MOCK_METHOD0(Connect, bool());
+ MOCK_METHOD0(GetConnection, std::vector<std::pair<sqlite3*, uid_t>>());
+ };
+
+ class DepInfoGetDBHandlerMock : public psd::DepInfoGetDBHandler {
+ public:
+ DepInfoGetDBHandlerMock(uid_t uid, int pid) :
+ psd::DepInfoGetDBHandler(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, PkgSetDBHandlerTest) {
+ 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("pkgA"), 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);
+ }
+
+ TEST_F(ParserDBHandlerTest, PkgGetDBHandlerTest) {
+ std::string pkgid = "pkgA";
+ 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(pkgid), 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);
+
+ pkgmgrinfo_pkginfo_filter_h filter;
+
+ ASSERT_EQ(pkgmgrinfo_pkginfo_filter_create(&filter), PMINFO_R_OK);
+ std::unique_ptr<pkgmgrinfo_filter_x, decltype(
+ pkgmgrinfo_pkginfo_filter_destroy)*> filter_ptr(
+ reinterpret_cast<pkgmgrinfo_filter_x *>(filter),
+ pkgmgrinfo_pkginfo_filter_destroy);
+ ASSERT_EQ(pkgmgrinfo_pkginfo_filter_add_string(filter,
+ PMINFO_PKGINFO_PROP_PACKAGE_ID, pkgid.c_str()), PMINFO_R_OK);
+ ASSERT_EQ(pkgmgrinfo_pkginfo_filter_add_bool(filter,
+ PMINFO_PKGINFO_PROP_PACKAGE_DISABLE, false), PMINFO_R_OK);
+
+ PkgGetDBHandlerMock pkg_get_db_handler(0, 0);
+ pkg_get_db_handler.SetFilter(filter_ptr.get());
+ pkg_get_db_handler.SetLocale("test_lang");
+
+ EXPECT_CALL(pkg_get_db_handler, Connect()).WillOnce(testing::Return(true));
+ EXPECT_CALL(pkg_get_db_handler, GetConnection())
+ .WillOnce(testing::Return(GetDBHandles()));
+ ASSERT_EQ(pkg_get_db_handler.Execute(), 0);
+
+ auto lpkginfo_list = pkg_get_db_handler.GetPkgHandle();
+ ASSERT_EQ(lpkginfo_list.size(), 1);
+
+ auto test_pkginfo = GetTestPackage(pkgid);
+ std::vector<package_x*> rpkginfo_list;
+ rpkginfo_list.emplace_back(test_pkginfo);
+
+ ASSERT_EQ(IsEqualPackagesInfo(lpkginfo_list, rpkginfo_list), true);
+ }
+
+ TEST_F(ParserDBHandlerTest, AppInfoDBHandlerTest) {
+ 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);
+
+ pkgmgrinfo_appinfo_filter_h filter;
+ std::string appid = "test_app1";
+
+ ASSERT_EQ(pkgmgrinfo_appinfo_filter_create(&filter), PMINFO_R_OK);
+ std::unique_ptr<pkgmgrinfo_filter_x, decltype(
+ pkgmgrinfo_appinfo_filter_destroy)*> filter_ptr(
+ reinterpret_cast<pkgmgrinfo_filter_x *>(filter),
+ pkgmgrinfo_appinfo_filter_destroy);
+ ASSERT_EQ(pkgmgrinfo_appinfo_filter_add_string(filter,
+ PMINFO_APPINFO_PROP_APP_ID, appid.c_str()), PMINFO_R_OK);
+ ASSERT_EQ(pkgmgrinfo_appinfo_filter_add_bool(filter,
+ PMINFO_APPINFO_PROP_APP_DISABLE, false), PMINFO_R_OK);
+
+ AppInfoDBHandlerMock appinfo_db_handler(0, 0);
+ appinfo_db_handler.SetFilter(filter_ptr.get());
+
+ EXPECT_CALL(appinfo_db_handler, Connect()).WillOnce(testing::Return(true));
+ EXPECT_CALL(appinfo_db_handler, GetConnection())
+ .WillOnce(testing::Return(GetDBHandles()));
+ appinfo_db_handler.SetLocale("test_lang");
+ ASSERT_EQ(appinfo_db_handler.Execute(), 0);
+
+ auto lappinfo_list = appinfo_db_handler.GetAppHandle();
+ ASSERT_EQ(lappinfo_list.size(), 1);
+
+ auto test_appinfo = GetTestApplication(appid);
+ std::vector<application_x*> rappinfo_list;
+ rappinfo_list.emplace_back(test_appinfo);
+
+ ASSERT_EQ(IsEqualApplicationsInfo(lappinfo_list, rappinfo_list), true);
+ }
+
+ TEST_F(ParserDBHandlerTest, DepInfoDBHandlerTest) {
+ 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);
+
+ DepInfoGetDBHandlerMock depinfo_get_db_handler(0, 0);
+ depinfo_get_db_handler.SetPkgID("depends_on_pkgid");
+ EXPECT_CALL(depinfo_get_db_handler,
+ Connect()).WillOnce(testing::Return(true));
+ EXPECT_CALL(depinfo_get_db_handler, GetConnection())
+ .WillOnce(testing::Return(GetDBHandles()));
+ ASSERT_EQ(depinfo_get_db_handler.Execute(), 0);
+
+ auto depinfo_from_db = depinfo_get_db_handler.GetDependencyList();
+ ASSERT_EQ(depinfo_from_db.size(), 1);
+
+ std::vector<dependency_x*> depinfo_list;
+ depinfo_list.emplace_back(GetTestDepInfo("test_package"));
+
+ 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::string>{
++ std::vector<std::pair<int, std::vector<std::optional<std::string>>>>{
+ std::make_pair(
+ QUERY_INDEX_INSERT_PACKAGE_PLUGIN_EXECUTION_INFO,
- std::vector<std::pair<int, std::vector<std::string>>>{
++ 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::string>{pkgid, plugin_type, plugin_name})});
++ std::vector<std::pair<int, std::vector<std::optional<std::string>>>>{
+ std::make_pair(
+ QUERY_INDEX_PLUGININFO_GET_APPIDS,
- std::vector<std::pair<int, std::vector<std::string>>> query_args;
- std::vector<std::vector<std::string>> expected_label;
++ 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::string>{app->appid, label->lang}));
- expected_label.emplace_back(std::vector<std::string>{label->text});
++ 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::pair<int, std::vector<std::string>>> query_args;
- std::vector<std::vector<std::string>> expected_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::string>{dc->providerid, dc->type}));
++ 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::string>{app->appid, dc->access});
++ std::vector<std::optional<std::string>>{dc->providerid, dc->type}));
+ expected_label.emplace_back(
- std::vector<std::pair<int, std::vector<std::string>>> query_args;
- std::vector<std::vector<std::string>> expected_appids;
- std::map<std::string, std::vector<std::string>> provider_map;
++ 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::string>{std::move(it.first)}));
++ 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);
+ }
projects / platform / core / appfw / pkgmgr-info.git / commitdiff