diff --git a/cli_tool_framework/services/climgr/BUILD.gn b/cli_tool_framework/services/climgr/BUILD.gn index bb8213bb28..ac268acc3b 100644 --- a/cli_tool_framework/services/climgr/BUILD.gn +++ b/cli_tool_framework/services/climgr/BUILD.gn @@ -42,6 +42,7 @@ ohos_shared_library("climgr") { "src/cli_tool_app_state_observer.cpp", "src/cli_tool_data_manager.cpp", "src/cli_tool_manager_service.cpp", + "src/permission_query_util.cpp", "src/process_manager.cpp", "src/session_record.cpp", "src/tool_util.cpp", diff --git a/cli_tool_framework/services/climgr/include/cli_tool_manager_service.h b/cli_tool_framework/services/climgr/include/cli_tool_manager_service.h index 6fad21c3db..f07afafb1d 100644 --- a/cli_tool_framework/services/climgr/include/cli_tool_manager_service.h +++ b/cli_tool_framework/services/climgr/include/cli_tool_manager_service.h @@ -159,22 +159,6 @@ private: bool initialized_ = false; std::shared_ptr ioMonitor_ = nullptr; - /** - * @brief Execute single command permission query. - */ - int32_t DoQueryPermission(const Command &cmd, std::vector &permissions); - - /** - * @brief Query main command permissions. - */ - int32_t QueryMainCommandPermission(const std::string &toolName, std::vector &permissions); - - /** - * @brief Query subcommand permissions. - */ - int32_t QuerySubCommandPermission(const std::string &toolName, const std::string &subCommand, - std::vector &permissions); - std::atomic interfaceCalledCount_ = 0; ffrt::mutex sessionsMutex_; std::unordered_map> sessionRecords_; diff --git a/cli_tool_framework/services/climgr/include/permission_query_util.h b/cli_tool_framework/services/climgr/include/permission_query_util.h new file mode 100644 index 0000000000..2f1bb2def6 --- /dev/null +++ b/cli_tool_framework/services/climgr/include/permission_query_util.h @@ -0,0 +1,105 @@ +/* + * Copyright (c) 2026 Huawei Device 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. + */ + +#ifndef OHOS_ABILITY_RUNTIME_PERMISSION_QUERY_UTIL_H +#define OHOS_ABILITY_RUNTIME_PERMISSION_QUERY_UTIL_H + +#include +#include +#include "cli_error_code.h" +#include "icli_tool_data.h" + +namespace OHOS { +namespace CliTool { + +/** + * @brief Query result codes for batch permission query + */ +namespace QueryResult { + constexpr int32_t SUCCESS = 0; + constexpr int32_t COMMAND_NOT_EXIST = 1; + constexpr int32_t DB_ERROR = 2; +} // namespace QueryResult + +/** + * @brief CLI tool permission query utility class + * Provides static methods to handle command permission query logic + */ +class PermissionQueryUtil { +public: + /** + * @brief Batch query command permissions + * @param cmds Command list to query + * @param cmdPermissions Output vector of CommandPermission query results + * @return ERR_OK on success + */ + static int32_t BatchQueryPermissions( + const std::vector &cmds, + std::vector &cmdPermissions); + +private: + /** + * @brief Query permissions for a single command + * @param cmd Command to query + * @param permissions Output vector of permission strings + * @return ERR_OK on success + * ERR_TOOL_NOT_EXIST when tool not found + * ERR_NO_INIT on database error + */ + static int32_t QuerySingleCommand( + const Command &cmd, + std::vector &permissions); + + /** + * @brief Query permissions for main command (no subcommand) + * @param toolName Tool name + * @param permissions Output vector of permission strings + * @return ERR_OK on success + * ERR_TOOL_NOT_EXIST when tool not found + * ERR_NO_INIT on database error + */ + static int32_t QueryMainCommandPermission( + const std::string &toolName, + std::vector &permissions); + + /** + * @brief Query permissions for subcommand + * @param toolName Tool name + * @param subCommand Subcommand name + * @param permissions Output vector of permission strings + * @return ERR_OK on success + * ERR_TOOL_NOT_EXIST when tool or subcommand not found + * ERR_NO_INIT on database error + */ + static int32_t QuerySubCommandPermission( + const std::string &toolName, + const std::string &subCommand, + std::vector &permissions); + + /** + * @brief Build CommandPermission result object + * @param cmd Command + * @param permissions Permission list + * @param queryRet Query result code + * @return CommandPermission object + */ + static CommandPermission BuildCommandPermission( + const Command &cmd, + const std::vector &permissions, + int32_t queryRet); +}; +} // namespace CliTool +} // namespace OHOS +#endif // OHOS_ABILITY_RUNTIME_PERMISSION_QUERY_UTIL_H diff --git a/cli_tool_framework/services/climgr/src/cli_tool_manager_service.cpp b/cli_tool_framework/services/climgr/src/cli_tool_manager_service.cpp index 1097b30ef4..a9819bed77 100644 --- a/cli_tool_framework/services/climgr/src/cli_tool_manager_service.cpp +++ b/cli_tool_framework/services/climgr/src/cli_tool_manager_service.cpp @@ -27,6 +27,7 @@ #include "if_system_ability_manager.h" #include "ipc_skeleton.h" #include "iservice_registry.h" +#include "permission_query_util.h" #include "permission_util.h" #include "process_manager.h" #include "session_record.h" @@ -864,112 +865,29 @@ int32_t CliToolManagerService::SendMessage(const std::string &sessionId, return ERR_OK; } -int32_t CliToolManagerService::BatchQueryPermissionBySubCommand(const std::vector &cmds, +int32_t CliToolManagerService::BatchQueryPermissionBySubCommand( + const std::vector &cmds, std::vector &cmdPermissions) { - TAG_LOGI(AAFwkTag::CLI_TOOL, "BatchQueryPermissionBySubCommand called, count=%{public}zu", cmds.size()); + TAG_LOGI(AAFwkTag::CLI_TOOL, "BatchQueryPermissionBySubCommand begin, cnt=%{public}zu", cmds.size()); InterfaceCallCounter counter(interfaceCalledCount_); if (cmds.empty() || cmds.size() >= MAX_QUERY_CMDS_SIZE) { - TAG_LOGE(AAFwkTag::CLI_TOOL, "Commands is empty or reach limit"); + TAG_LOGE(AAFwkTag::CLI_TOOL, "cmds is empty or reach limit"); return ERR_INVALID_PARAM; } - Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID(); - Security::AccessToken::ATokenTypeEnum tokenType = - Security::AccessToken::AccessTokenKit::GetTokenTypeFlag(callerToken); - if (tokenType != Security::AccessToken::ATokenTypeEnum::TOKEN_NATIVE) { + auto callerToken = IPCSkeleton::GetCallingTokenID(); + if (Security::AccessToken::AccessTokenKit::GetTokenTypeFlag(callerToken) != + Security::AccessToken::ATokenTypeEnum::TOKEN_NATIVE) { TAG_LOGE(AAFwkTag::CLI_TOOL, "Caller is not SA"); return ERR_NOT_SA_CALLER; } - int ret = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken, "ohos.permission.QUERY_CLI_TOOL"); - if (ret != Security::AccessToken::PermissionState::PERMISSION_GRANTED) { - TAG_LOGE(AAFwkTag::CLI_TOOL, "Permission denied: ohos.permission.QUERY_CLI_TOOL"); + if (!PermissionUtil::VerifyAccessToken(callerToken, PERMISSION_QUERY_CLI_TOOL)) { return ERR_PERMISSION_DENIED; } - TAG_LOGI(AAFwkTag::CLI_TOOL, "BatchQueryPermissionBySubCommand begin"); - cmdPermissions.clear(); - cmdPermissions.reserve(cmds.size()); - - for (const auto &cmd : cmds) { - CommandPermission cmdPerm; - cmdPerm.cmd = cmd; - cmdPerm.permissions.clear(); - if (cmd.toolName.empty()) { - TAG_LOGE(AAFwkTag::CLI_TOOL, "Tool name is empty"); - return ERR_INVALID_PARAM; - } - - int32_t ret = DoQueryPermission(cmd, cmdPerm.permissions); - if (ret == ERR_OK) { - cmdPerm.queryRet = QUERY_SUCCESS; - } else if (ret == ERR_TOOL_NOT_EXIST) { - cmdPerm.queryRet = QUERY_COMMAND_NOT_EXIST; - cmdPerm.permissions.clear(); - } else { - // ERR_NO_INIT - cmdPerm.queryRet = QUERY_DB_ERROR; - cmdPerm.permissions.clear(); - } - cmdPermissions.push_back(std::move(cmdPerm)); - } - - TAG_LOGI(AAFwkTag::CLI_TOOL, "Batch query completed, total=%{public}zu", cmdPermissions.size()); - return ERR_OK; -} - -int32_t CliToolManagerService::DoQueryPermission(const Command &cmd, std::vector &permissions) -{ - if (cmd.subCommand.empty()) { - return QueryMainCommandPermission(cmd.toolName, permissions); - } - return QuerySubCommandPermission(cmd.toolName, cmd.subCommand, permissions); -} - -int32_t CliToolManagerService::QueryMainCommandPermission(const std::string &toolName, - std::vector &permissions) -{ - ToolInfo toolInfo; - int32_t ret = CliToolDataManager::GetInstance().GetToolByName(toolName, toolInfo); - if (ret == ERR_NO_INIT) { - TAG_LOGE(AAFwkTag::CLI_TOOL, "DB error when querying tool: %{public}s", toolName.c_str()); - return ERR_NO_INIT; - } else if (ret != ERR_OK) { - TAG_LOGE(AAFwkTag::CLI_TOOL, "Tool not found: %{public}s", toolName.c_str()); - return ERR_TOOL_NOT_EXIST; - } - permissions = toolInfo.requirePermissions; - return ERR_OK; -} - -int32_t CliToolManagerService::QuerySubCommandPermission(const std::string &toolName, const std::string &subCommand, - std::vector &permissions) -{ - ToolInfo toolInfo; - int32_t ret = CliToolDataManager::GetInstance().GetToolByName(toolName, toolInfo); - if (ret == ERR_NO_INIT) { - TAG_LOGE(AAFwkTag::CLI_TOOL, "DB error when querying tool: %{public}s", toolName.c_str()); - return ERR_NO_INIT; - } else if (ret != ERR_OK) { - TAG_LOGE(AAFwkTag::CLI_TOOL, "Tool not found: %{public}s", toolName.c_str()); - return ERR_TOOL_NOT_EXIST; - } - - if (!toolInfo.hasSubCommand) { - TAG_LOGE(AAFwkTag::CLI_TOOL, "Tool has no subcommand: %{public}s", toolName.c_str()); - return ERR_TOOL_NOT_EXIST; - } - - auto it = toolInfo.subcommands.find(subCommand); - if (it == toolInfo.subcommands.end()) { - TAG_LOGE(AAFwkTag::CLI_TOOL, "Subcommand not found: %{public}s.%{public}s", - toolName.c_str(), subCommand.c_str()); - return ERR_TOOL_NOT_EXIST; - } - - permissions = it->second.requirePermissions; - return ERR_OK; + return PermissionQueryUtil::BatchQueryPermissions(cmds, cmdPermissions); } } // namespace CliTool } // namespace OHOS diff --git a/cli_tool_framework/services/climgr/src/permission_query_util.cpp b/cli_tool_framework/services/climgr/src/permission_query_util.cpp new file mode 100644 index 0000000000..437a043d5e --- /dev/null +++ b/cli_tool_framework/services/climgr/src/permission_query_util.cpp @@ -0,0 +1,118 @@ +/* + * Copyright (c) 2026 Huawei Device 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 "permission_query_util.h" +#include "cli_tool_data_manager.h" +#include "hilog_tag_wrapper.h" + +namespace OHOS { +namespace CliTool { +int32_t PermissionQueryUtil::BatchQueryPermissions( + const std::vector &cmds, + std::vector &cmdPermissions) +{ + cmdPermissions.clear(); + cmdPermissions.reserve(cmds.size()); + for (const auto &cmd : cmds) { + std::vector permissions; + int32_t ret = QuerySingleCommand(cmd, permissions); + int32_t queryRet; + if (ret == ERR_OK) { + queryRet = QueryResult::SUCCESS; + } else if (ret == ERR_TOOL_NOT_EXIST) { + queryRet = QueryResult::COMMAND_NOT_EXIST; + permissions.clear(); + } else { + queryRet = QueryResult::DB_ERROR; + permissions.clear(); + } + cmdPermissions.push_back(BuildCommandPermission(cmd, permissions, queryRet)); + } + TAG_LOGI(AAFwkTag::CLI_TOOL, "Batch query completed, total=%{public}zu", cmdPermissions.size()); + return ERR_OK; +} + +int32_t PermissionQueryUtil::QuerySingleCommand( + const Command &cmd, + std::vector &permissions) +{ + if (cmd.toolName.empty()) { + TAG_LOGW(AAFwkTag::CLI_TOOL, "Tool name is empty"); + return ERR_TOOL_NOT_EXIST; + } + if (cmd.subCommand.empty()) { + return QueryMainCommandPermission(cmd.toolName, permissions); + } + return QuerySubCommandPermission(cmd.toolName, cmd.subCommand, permissions); +} + +int32_t PermissionQueryUtil::QueryMainCommandPermission( + const std::string &toolName, + std::vector &permissions) +{ + ToolInfo toolInfo; + int32_t ret = CliToolDataManager::GetInstance().GetToolByName(toolName, toolInfo); + if (ret == ERR_NO_INIT) { + TAG_LOGE(AAFwkTag::CLI_TOOL, "DB error when querying tool: %{public}s", toolName.c_str()); + return ERR_NO_INIT; + } else if (ret != ERR_OK) { + TAG_LOGE(AAFwkTag::CLI_TOOL, "Tool not found: %{public}s", toolName.c_str()); + return ERR_TOOL_NOT_EXIST; + } + permissions = toolInfo.requirePermissions; + return ERR_OK; +} + +int32_t PermissionQueryUtil::QuerySubCommandPermission( + const std::string &toolName, + const std::string &subCommand, + std::vector &permissions) +{ + ToolInfo toolInfo; + int32_t ret = CliToolDataManager::GetInstance().GetToolByName(toolName, toolInfo); + if (ret == ERR_NO_INIT) { + TAG_LOGE(AAFwkTag::CLI_TOOL, "DB error when querying tool: %{public}s", toolName.c_str()); + return ERR_NO_INIT; + } else if (ret != ERR_OK) { + TAG_LOGE(AAFwkTag::CLI_TOOL, "Tool not found: %{public}s", toolName.c_str()); + return ERR_TOOL_NOT_EXIST; + } + if (!toolInfo.hasSubCommand) { + TAG_LOGE(AAFwkTag::CLI_TOOL, "Tool has no subcommand: %{public}s", toolName.c_str()); + return ERR_TOOL_NOT_EXIST; + } + auto it = toolInfo.subcommands.find(subCommand); + if (it == toolInfo.subcommands.end()) { + TAG_LOGE(AAFwkTag::CLI_TOOL, "Subcommand not found: %{public}s.%{public}s", + toolName.c_str(), subCommand.c_str()); + return ERR_TOOL_NOT_EXIST; + } + permissions = it->second.requirePermissions; + return ERR_OK; +} + +CommandPermission PermissionQueryUtil::BuildCommandPermission( + const Command &cmd, + const std::vector &permissions, + int32_t queryRet) +{ + CommandPermission cmdPerm; + cmdPerm.cmd = cmd; + cmdPerm.permissions = permissions; + cmdPerm.queryRet = queryRet; + return cmdPerm; +} +} // namespace CliTool +} // namespace OHOS diff --git a/cli_tool_framework/test/unittest/BUILD.gn b/cli_tool_framework/test/unittest/BUILD.gn index a9ed144e6b..f471baa504 100644 --- a/cli_tool_framework/test/unittest/BUILD.gn +++ b/cli_tool_framework/test/unittest/BUILD.gn @@ -20,6 +20,7 @@ group("unittest") { "cli_tool_data_manager_test:cli_tool_data_manager_test", "cli_tool_mgr_client_test:cli_tool_mgr_client_test", "cli_tool_mgr_service_test:cli_tool_mgr_service_test", + "permission_query_util_test:permission_query_util_test", "process_manager_test:process_manager_test", "sub_command_info_test:sub_command_info_test", "tool_info_test:tool_info_test", diff --git a/cli_tool_framework/test/unittest/cli_tool_mgr_service_test/BUILD.gn b/cli_tool_framework/test/unittest/cli_tool_mgr_service_test/BUILD.gn index 5830d5658d..adc8ad5c7c 100644 --- a/cli_tool_framework/test/unittest/cli_tool_mgr_service_test/BUILD.gn +++ b/cli_tool_framework/test/unittest/cli_tool_mgr_service_test/BUILD.gn @@ -34,6 +34,7 @@ ohos_unittest("cli_tool_mgr_service_test") { "${cli_tool_framework_path}/services/climgr/src/cli_tool_manager_service.cpp", "${cli_tool_framework_path}/services/climgr/src/event_dispatcher.cpp", "${cli_tool_framework_path}/services/climgr/src/io_monitor.cpp", + "${cli_tool_framework_path}/services/climgr/src/permission_query_util.cpp", "${cli_tool_framework_path}/services/climgr/src/process_manager.cpp", "${cli_tool_framework_path}/services/climgr/src/session_record.cpp", "${cli_tool_framework_path}/services/climgr/src/tool_util.cpp", diff --git a/cli_tool_framework/test/unittest/permission_query_util_test/BUILD.gn b/cli_tool_framework/test/unittest/permission_query_util_test/BUILD.gn new file mode 100644 index 0000000000..c946efab40 --- /dev/null +++ b/cli_tool_framework/test/unittest/permission_query_util_test/BUILD.gn @@ -0,0 +1,69 @@ +# Copyright (c) 2026 Huawei Device 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. + +import("//build/test.gni") +import("//foundation/ability/ability_runtime/ability_runtime.gni") + +module_output_path = "ability_runtime/ability_runtime/clitool" + +ohos_unittest("permission_query_util_test") { + module_out_path = module_output_path + + include_dirs = [ + "${ability_runtime_path}/cli_tool_framework/interfaces/cli_tool/include", + "${ability_runtime_path}/cli_tool_framework/services/climgr/include", + "${ability_runtime_path}/interfaces/kits/native/appkit/ability_bundle_manager_helper", + "${ability_runtime_services_path}/common/include", + "${cli_tool_framework_path}/services/common/include", + ] + + sources = [ + "permission_query_util_test.cpp", + "${cli_tool_framework_path}/services/climgr/src/cli_tool_data_manager.cpp", + "${cli_tool_framework_path}/services/climgr/src/permission_query_util.cpp", + "${cli_tool_framework_path}/services/common/src/permission_util.cpp", + ] + + cflags = [] + if (target_cpu == "arm") { + cflags += [ "-DBINDER_IPC_32BIT" ] + } + + deps = [ + "${ability_runtime_path}/cli_tool_framework/interfaces/cli_tool:cli_tool_client", + "${ability_runtime_path}/cli_tool_framework/services/climgr:climgr", + ] + + external_deps = [ + "ability_base:want", + "access_token:libaccesstoken_sdk", + "access_token:libtokenid_sdk", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "googletest:gmock_main", + "googletest:gtest_main", + "hilog:libhilog", + "ipc:ipc_core", + "json:nlohmann_json_static", + "kv_store:distributeddata_inner", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + ] +} + +group("unittest") { + testonly = true + + deps = [ ":permission_query_util_test" ] +} diff --git a/cli_tool_framework/test/unittest/permission_query_util_test/permission_query_util_test.cpp b/cli_tool_framework/test/unittest/permission_query_util_test/permission_query_util_test.cpp new file mode 100644 index 0000000000..e8294e547e --- /dev/null +++ b/cli_tool_framework/test/unittest/permission_query_util_test/permission_query_util_test.cpp @@ -0,0 +1,262 @@ +/* + * Copyright (c) 2026 Huawei Device 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 +#include +#include +#include + +#define private public +#include "permission_query_util.h" +#undef private +#include "cli_error_code.h" +#include "icli_tool_data.h" +#include "tool_info.h" + +using namespace testing::ext; +using namespace OHOS::CliTool; + +namespace OHOS { +namespace CliTool { +namespace { +// Mock test data +constexpr const char* TEST_TOOL_NAME = "test_tool"; +constexpr const char* TEST_SUBCOMMAND = "build"; +constexpr const char* TEST_PERMISSION_1 = "ohos.permission.TEST_PERMISSION_1"; +constexpr const char* TEST_PERMISSION_2 = "ohos.permission.TEST_PERMISSION_2"; + +// Helper function to create a test Command +Command CreateTestCommand(const std::string& toolName, const std::string& subCommand = "") +{ + Command cmd; + cmd.toolName = toolName; + cmd.subCommand = subCommand; + return cmd; +} +} // namespace + +class PermissionQueryUtilTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); +}; + +void PermissionQueryUtilTest::SetUpTestCase() +{ + // Initialize test environment +} + +void PermissionQueryUtilTest::TearDownTestCase() +{ + // Cleanup test environment +} + +void PermissionQueryUtilTest::SetUp() +{ + // Reset state before each test +} + +void PermissionQueryUtilTest::TearDown() +{ + // Cleanup after each test +} + +/** + * @tc.name: PermissionQueryUtil::BatchQueryPermissions_001 + * @tc.desc: Test batch query with empty command list + * @tc.type: FUNC + */ +HWTEST_F(PermissionQueryUtilTest, BatchQueryPermissions_EmptyCommands, TestSize.Level1) +{ + std::vector cmds; + std::vector cmdPermissions; + + int32_t ret = PermissionQueryUtil::BatchQueryPermissions(cmds, cmdPermissions); + + EXPECT_EQ(ret, ERR_OK); + EXPECT_EQ(cmdPermissions.size(), 0u); +} + +/** + * @tc.name: PermissionQueryUtil::BatchQueryPermissions_002 + * @tc.desc: Test batch query with non-existent tool + * @tc.type: FUNC + */ +HWTEST_F(PermissionQueryUtilTest, BatchQueryPermissions_ToolNotExist, TestSize.Level1) +{ + std::vector cmds; + cmds.push_back(CreateTestCommand("non_existent_tool")); + + std::vector cmdPermissions; + + int32_t ret = PermissionQueryUtil::BatchQueryPermissions(cmds, cmdPermissions); + + EXPECT_EQ(ret, ERR_OK); + EXPECT_EQ(cmdPermissions.size(), 1u); + EXPECT_EQ(cmdPermissions[0].queryRet, QueryResult::COMMAND_NOT_EXIST); + EXPECT_EQ(cmdPermissions[0].permissions.size(), 0u); +} + +/** + * @tc.name: PermissionQueryUtil::BatchQueryPermissions_003 + * @tc.desc: Test batch query with empty tool name + * @tc.type: FUNC + */ +HWTEST_F(PermissionQueryUtilTest, BatchQueryPermissions_EmptyToolName, TestSize.Level1) +{ + std::vector cmds; + Command cmd; + cmd.toolName = ""; + cmds.push_back(cmd); + + std::vector cmdPermissions; + + int32_t ret = PermissionQueryUtil::BatchQueryPermissions(cmds, cmdPermissions); + + EXPECT_EQ(ret, ERR_OK); + EXPECT_EQ(cmdPermissions.size(), 1u); + EXPECT_EQ(cmdPermissions[0].queryRet, QueryResult::COMMAND_NOT_EXIST); + EXPECT_EQ(cmdPermissions[0].permissions.size(), 0u); +} + +/** + * @tc.name: PermissionQueryUtil::BatchQueryPermissions_004 + * @tc.desc: Test batch query clears output parameter + * @tc.type: FUNC + */ +HWTEST_F(PermissionQueryUtilTest, BatchQueryPermissions_ClearsOutputParameter, TestSize.Level1) +{ + std::vector cmdPermissions; + CommandPermission oldPerm; + oldPerm.cmd.toolName = "old_tool"; + oldPerm.queryRet = 99; + oldPerm.permissions.push_back("old_permission"); + cmdPermissions.push_back(oldPerm); + + EXPECT_EQ(cmdPermissions.size(), 1u); + EXPECT_EQ(cmdPermissions[0].cmd.toolName, "old_tool"); + + std::vector cmds; + int32_t ret = PermissionQueryUtil::BatchQueryPermissions(cmds, cmdPermissions); + + EXPECT_EQ(ret, ERR_OK); + EXPECT_EQ(cmdPermissions.size(), 0u); +} + +/** + * @tc.name: PermissionQueryUtil::BatchQueryPermissions_005 + * @tc.desc: Test batch query with multiple commands + * @tc.type: FUNC + */ +HWTEST_F(PermissionQueryUtilTest, BatchQueryPermissions_MultipleCommands, TestSize.Level1) +{ + std::vector cmds; + cmds.push_back(CreateTestCommand("tool1")); + cmds.push_back(CreateTestCommand("tool2", "sub1")); + cmds.push_back(CreateTestCommand("tool3")); + + std::vector cmdPermissions; + + int32_t ret = PermissionQueryUtil::BatchQueryPermissions(cmds, cmdPermissions); + + EXPECT_EQ(ret, ERR_OK); + EXPECT_EQ(cmdPermissions.size(), 3u); + + EXPECT_EQ(cmdPermissions[0].queryRet, QueryResult::COMMAND_NOT_EXIST); + EXPECT_EQ(cmdPermissions[0].permissions.size(), 0u); + + EXPECT_EQ(cmdPermissions[1].queryRet, QueryResult::COMMAND_NOT_EXIST); + EXPECT_EQ(cmdPermissions[1].permissions.size(), 0u); + + EXPECT_EQ(cmdPermissions[2].queryRet, QueryResult::COMMAND_NOT_EXIST); + EXPECT_EQ(cmdPermissions[2].permissions.size(), 0u); +} + +/** + * @tc.name: PermissionQueryUtil::QuerySingleCommand_001 + * @tc.desc: Test QuerySingleCommand with empty tool name + * @tc.type: FUNC + */ +HWTEST_F(PermissionQueryUtilTest, QuerySingleCommand_EmptyToolName, TestSize.Level1) +{ + Command cmd; + cmd.toolName = ""; + std::vector permissions; + + int32_t ret = PermissionQueryUtil::QuerySingleCommand(cmd, permissions); + + EXPECT_EQ(ret, ERR_TOOL_NOT_EXIST); + EXPECT_EQ(permissions.size(), 0u); +} + +/** + * @tc.name: PermissionQueryUtil::QuerySingleCommand_002 + * @tc.desc: Test QuerySingleCommand with non-existent tool + * @tc.type: FUNC + */ +HWTEST_F(PermissionQueryUtilTest, QuerySingleCommand_ToolNotExist, TestSize.Level1) +{ + Command cmd = CreateTestCommand("non_existent_tool"); + std::vector permissions; + + int32_t ret = PermissionQueryUtil::QuerySingleCommand(cmd, permissions); + + EXPECT_EQ(ret, ERR_TOOL_NOT_EXIST); + EXPECT_EQ(permissions.size(), 0u); +} + +/** + * @tc.name: PermissionQueryUtil::BuildCommandPermission_001 + * @tc.desc: Test BuildCommandPermission creates correct object + * @tc.type: FUNC + */ +HWTEST_F(PermissionQueryUtilTest, BuildCommandPermission_CreatesCorrectObject, TestSize.Level1) +{ + Command cmd = CreateTestCommand(TEST_TOOL_NAME, TEST_SUBCOMMAND); + std::vector permissions = {TEST_PERMISSION_1, TEST_PERMISSION_2}; + int32_t queryRet = QueryResult::SUCCESS; + + CommandPermission cmdPerm = PermissionQueryUtil::BuildCommandPermission(cmd, permissions, queryRet); + + EXPECT_EQ(cmdPerm.cmd.toolName, TEST_TOOL_NAME); + EXPECT_EQ(cmdPerm.cmd.subCommand, TEST_SUBCOMMAND); + EXPECT_EQ(cmdPerm.queryRet, QueryResult::SUCCESS); + EXPECT_EQ(cmdPerm.permissions.size(), 2u); + EXPECT_EQ(cmdPerm.permissions[0], TEST_PERMISSION_1); + EXPECT_EQ(cmdPerm.permissions[1], TEST_PERMISSION_2); +} + +/** + * @tc.name: PermissionQueryUtil::BuildCommandPermission_002 + * @tc.desc: Test BuildCommandPermission with empty permissions + * @tc.type: FUNC + */ +HWTEST_F(PermissionQueryUtilTest, BuildCommandPermission_EmptyPermissions, TestSize.Level1) +{ + Command cmd = CreateTestCommand(TEST_TOOL_NAME); + std::vector permissions; + int32_t queryRet = QueryResult::COMMAND_NOT_EXIST; + + CommandPermission cmdPerm = PermissionQueryUtil::BuildCommandPermission(cmd, permissions, queryRet); + + EXPECT_EQ(cmdPerm.cmd.toolName, TEST_TOOL_NAME); + EXPECT_EQ(cmdPerm.cmd.subCommand, ""); + EXPECT_EQ(cmdPerm.queryRet, QueryResult::COMMAND_NOT_EXIST); + EXPECT_EQ(cmdPerm.permissions.size(), 0u); +} +} // namespace CliTool +} // namespace OHOS