!19240 merge batch into master

batchQuery规格变更

Created-by: xuzheheng
Commit-by: xuzheheng
Merged-by: openharmony_ci
Description: **IssueNo**:
https://gitcode.com/openharmony/ability_ability_runtime/issues/15184
**Description**:

**稳定性自检:**
| 自检项                                                       | 自检结果  |
| ------------------------------------------------------------ | -------- |
| 涉及跨进程调用的相关操作需要抛至主线程或加锁防止并发              |    ok      |
| 成员变量进行赋值或创建需要排查并发                               |     ok     |
| 谨慎在lambda表达式中使用引用捕获                                |      ok    |
| 谨慎在未经拷贝的情况下使用外部传入的string、C字符串               |     ok     |
| map\vector\list\set等stl模板类使用时需要排查并发                |   ok       |
| 谨慎考虑加锁范围                                               |   ok       |
| 在IPC通信中谨慎使用同步通信方式                                 |       ok   |
| 禁止传递this指针至其他模块或线程(特别是eventhandler任务)        |      ok    |
| 禁止将外部传入的裸指针在内部直接构造智能指针                      |   ok       |
| 禁止多个独立创建的智能指针管理同一地址                           |      ok    |
| 禁止在析构函数中抛异步任务                                      |    ok      |
| 禁止js对象在非js线程(例如在IPC线程)创建、使用或销毁             |   ok       |
| 禁止在对外接口中未经判空直接使用外部传入的指针                    |       ok   |
| 禁止接口返回局部变量引用                                        |    ok      |
| 禁止在信号函数中加锁                                            |      ok    |
| 禁止在关键流程(SA启动、应用启动等主流程)执行耗时的操作           |      ok    |
| 禁止将同一个cpp编译在不同的so中                                 |      ok    |

**安全编码自检:**
| 自检项                                                          | 自检结果 |
| -------------------------------------------------------------- | -------- |
| 裸指针避免通过隐式转换构造为sptr                                 |     ok     |
| json对象在取值之前必须先判断类型,避免类型不匹配                   |    ok      |
| 序列化时必须对传入的数组大小进行校验,避免出现超大数组              |    ok      |
| 避免使用未明确位宽的整型,选择使用int8_t、uint8_t等类型            |     ok     |
| 外部传入的路径要做规范化校验,对路径中的.、..、../等特殊字符严格校验 |    ok      |
| 指针变量、表示资源描述符的变量、bool变量必须赋初值                  |     ok     |
| readParcelable获取的对象使用前需要判空                            |     ok     |
| 分配和释放内存的函数需要成对出现                                   |      ok    |
| 申请内存后异常退出前需要及时进行内存释放                            |       ok   |
| 内存申请前必须对内存大小进行合法性校验                              |      ok    |
| 内存分配后必须判断是否成功                                         |      ok    |
| 禁止使用realloc、alloca函数                                       |    ok      |
| 禁止打印文件路径、口令等敏感信息,如有需要,使用private修饰          |      ok    |
| 禁止打印内存地址                                                  |     ok     |
| 整数之间运算时必须严格检查,确保不会出现溢出、反转、除0               |     ok     |
| 禁止对有符号整数进行位操作符运算                                    |       ok   |
| 禁止对指针进行逻辑或位运算                                         |     ok     |
| 循环次数如果收外部数据控制,需要检验其合法性                         |      ok    |
| 禁止使用内存操作类危险函数,需要使用安全函数                         |    ok      |
| 谨慎使用不可重入函数                                               |     ok     |
| 必须检查安全函数的返回值,并进行正确处理                             |      ok    |
| 禁止仅通过TokenType类型判断绕过权限校验                             |      ok    |

**TDD Result**:ok

**XTS Result**:ok

### 是否已执行L0用例
- [ ok] 已验证
- [ ] 不涉及。如不涉及,请写明理由


See merge request: openharmony/ability_ability_runtime!19240
This commit is contained in:
openharmony_ci
2026-05-09 15:45:59 +08:00
9 changed files with 567 additions and 108 deletions
@@ -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",
@@ -159,22 +159,6 @@ private:
bool initialized_ = false;
std::shared_ptr<IOMonitor> ioMonitor_ = nullptr;
/**
* @brief Execute single command permission query.
*/
int32_t DoQueryPermission(const Command &cmd, std::vector<std::string> &permissions);
/**
* @brief Query main command permissions.
*/
int32_t QueryMainCommandPermission(const std::string &toolName, std::vector<std::string> &permissions);
/**
* @brief Query subcommand permissions.
*/
int32_t QuerySubCommandPermission(const std::string &toolName, const std::string &subCommand,
std::vector<std::string> &permissions);
std::atomic<int32_t> interfaceCalledCount_ = 0;
ffrt::mutex sessionsMutex_;
std::unordered_map<std::string, std::shared_ptr<SessionRecord>> sessionRecords_;
@@ -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 <string>
#include <vector>
#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<Command> &cmds,
std::vector<CommandPermission> &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<std::string> &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<std::string> &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<std::string> &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<std::string> &permissions,
int32_t queryRet);
};
} // namespace CliTool
} // namespace OHOS
#endif // OHOS_ABILITY_RUNTIME_PERMISSION_QUERY_UTIL_H
@@ -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<Command> &cmds,
int32_t CliToolManagerService::BatchQueryPermissionBySubCommand(
const std::vector<Command> &cmds,
std::vector<CommandPermission> &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<std::string> &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<std::string> &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<std::string> &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
@@ -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<Command> &cmds,
std::vector<CommandPermission> &cmdPermissions)
{
cmdPermissions.clear();
cmdPermissions.reserve(cmds.size());
for (const auto &cmd : cmds) {
std::vector<std::string> 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<std::string> &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<std::string> &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<std::string> &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<std::string> &permissions,
int32_t queryRet)
{
CommandPermission cmdPerm;
cmdPerm.cmd = cmd;
cmdPerm.permissions = permissions;
cmdPerm.queryRet = queryRet;
return cmdPerm;
}
} // namespace CliTool
} // namespace OHOS
@@ -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",
@@ -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",
@@ -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" ]
}
@@ -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 <gmock/gmock.h>
#include <gtest/gtest.h>
#include <memory>
#include <vector>
#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<Command> cmds;
std::vector<CommandPermission> 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<Command> cmds;
cmds.push_back(CreateTestCommand("non_existent_tool"));
std::vector<CommandPermission> 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<Command> cmds;
Command cmd;
cmd.toolName = "";
cmds.push_back(cmd);
std::vector<CommandPermission> 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<CommandPermission> 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<Command> 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<Command> cmds;
cmds.push_back(CreateTestCommand("tool1"));
cmds.push_back(CreateTestCommand("tool2", "sub1"));
cmds.push_back(CreateTestCommand("tool3"));
std::vector<CommandPermission> 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<std::string> 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<std::string> 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<std::string> 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<std::string> 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