diff --git a/interfaces/innerkits/accesstoken/test/unittest/BUILD.gn b/interfaces/innerkits/accesstoken/test/unittest/BUILD.gn index 690a6054d657bba0a36d08bed5f43fb16502510e..1808c7cde1dcf74a546af5b86da723c837cc7102 100755 --- a/interfaces/innerkits/accesstoken/test/unittest/BUILD.gn +++ b/interfaces/innerkits/accesstoken/test/unittest/BUILD.gn @@ -37,6 +37,7 @@ ohos_unittest("libaccesstoken_sdk_test") { ] sources = [ + "Coverage/accesstoken_kit_coverage_test.cpp", "DistributedTest/alloc_local_token_id_test.cpp", "DistributedTest/delete_remote_device_tokens_test.cpp", "DistributedTest/delete_remote_token_test.cpp", @@ -44,19 +45,23 @@ ohos_unittest("libaccesstoken_sdk_test") { "DistributedTest/get_remote_native_tokenid_test.cpp", "DistributedTest/register_token_sync_callback_test.cpp", "DistributedTest/set_remote_hap_token_info_test.cpp", + "EdmPolicyTest/edm_policy_set_test.cpp", "HapAttributeTest/get_hap_dlp_flag_test.cpp", "HapAttributeTest/get_permission_flag_test.cpp", "HapAttributeTest/get_permissions_status_test.cpp", - "HapAttributeTest/get_self_permissions_state_test.cpp", "HapAttributeTest/permission_request_toggle_status_test.cpp", - "HapAttributeTest/set_perm_dialog_cap_test.cpp", - "HapAttributeTest/user_policy_test.cpp", + "HapTokenTest/alloc_hap_token_test.cpp", + "HapTokenTest/app_installation_optimized_test.cpp", "HapTokenTest/delete_token_test.cpp", "HapTokenTest/get_hap_token_test.cpp", "HapTokenTest/get_token_type_test.cpp", "HapTokenTest/init_hap_token_test.cpp", "HapTokenTest/update_hap_token_test.cpp", "PermDenyTest/accesstoken_deny_test.cpp", + "PermisionDialogTest/accesstoken_location_request_test.cpp", + "PermisionDialogTest/get_self_permission_state_test.cpp", + "PermisionDialogTest/request_permission_on_setting_test.cpp", + "PermisionDialogTest/set_perm_dialog_cap_test.cpp", "PermissionsTest/check_permission_map_test.cpp", "PermissionsTest/clear_user_granted__permission_state_test.cpp", "PermissionsTest/get_permission_test.cpp", @@ -70,16 +75,8 @@ ohos_unittest("libaccesstoken_sdk_test") { "SaTest/get_native_token_id_test.cpp", "SaTest/get_native_token_info_test.cpp", "SaTest/get_version_test.cpp", + "SecurityComponentTest/security_component_grant_test.cpp", "common/test_common.cpp", - "src/accesstoken_kit_extension_test.cpp", - "src/accesstoken_kit_test.cpp", - "src/accesstoken_location_request_test.cpp", - "src/accesstoken_short_time_permission_test.cpp", - "src/app_installation_optimized_test.cpp", - "src/clone_app_permission_test.cpp", - "src/edm_policy_set_test.cpp", - "src/get_self_permission_state_test.cpp", - "src/security_component_grant_test.cpp", ] cflags_cc = [ "-DHILOG_ENABLE" ] @@ -112,7 +109,13 @@ ohos_unittest("libaccesstoken_sdk_test") { } if (dlp_permission_enable == true) { cflags_cc += [ "-DSUPPORT_SANDBOX_APP" ] - sources += [ "src/share_permission_with_sandbox_test.cpp" ] + sources += [ + "DlpTest/clone_app_permission_test.cpp", + "DlpTest/share_permission_with_sandbox_test.cpp", + ] + } + if (build_variant == "user") { + cflags_cc += [ "-DATM_BUILD_VARIANT_USER_ENABLE" ] } } @@ -179,4 +182,7 @@ ohos_unittest("accesstoken_mock_test") { if (token_sync_enable == true) { cflags_cc += [ "-DTOKEN_SYNC_ENABLE" ] } + if (build_variant == "user") { + cflags_cc += [ "-DATM_BUILD_VARIANT_USER_ENABLE" ] + } } diff --git a/interfaces/innerkits/accesstoken/test/unittest/Coverage/accesstoken_kit_coverage_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/Coverage/accesstoken_kit_coverage_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..1f1c76a04026ffa3af42ba262a4d44c4472dd265 --- /dev/null +++ b/interfaces/innerkits/accesstoken/test/unittest/Coverage/accesstoken_kit_coverage_test.cpp @@ -0,0 +1,526 @@ +/* + * Copyright (c) 2025 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 "accesstoken_kit_coverage_test.h" +#include + +#include "access_token.h" +#include "access_token_error.h" +#include "accesstoken_common_log.h" +#include "accesstoken_service_ipc_interface_code.h" +#include "hap_token_info.h" +#include "nativetoken_kit.h" +#include "permission_grant_info.h" +#include "permission_state_change_info_parcel.h" +#include "string_ex.h" +#include "test_common.h" +#include "tokenid_kit.h" +#include "token_setproc.h" +#define private public +#include "accesstoken_manager_client.h" +#undef private + +using namespace testing::ext; + +namespace OHOS { +namespace Security { +namespace AccessToken { +namespace { +static constexpr int32_t DEFAULT_API_VERSION = 8; +static const std::string TEST_BUNDLE_NAME = "ohos"; +static const std::string TEST_PERMISSION_NAME_ALPHA = "ohos.permission.ALPHA"; +static const std::string TEST_PERMISSION_NAME_BETA = "ohos.permission.BETA"; +static const int TEST_USER_ID = 0; +uint64_t g_selfShellTokenId; +} + +void AccessTokenCoverageTest::SetUpTestCase() +{ + g_selfShellTokenId = GetSelfTokenID(); + TestCommon::SetTestEvironment(g_selfShellTokenId); +} + +void AccessTokenCoverageTest::TearDownTestCase() +{ + SetSelfTokenID(g_selfShellTokenId); + TestCommon::ResetTestEvironment(); +} + +void AccessTokenCoverageTest::SetUp() +{ + g_selfShellTokenId = GetSelfTokenID(); + LOGI(ATM_DOMAIN, ATM_TAG, "SetUp ok."); +} + +void AccessTokenCoverageTest::TearDown() +{ + EXPECT_EQ(0, SetSelfTokenID(g_selfShellTokenId)); +} + +class CbCustomizeTest : public PermStateChangeCallbackCustomize { +public: + explicit CbCustomizeTest(const PermStateChangeScope &scopeInfo) + : PermStateChangeCallbackCustomize(scopeInfo) + { + } + + ~CbCustomizeTest() + {} + + virtual void PermStateChangeCallback(PermStateChangeInfo& result) + { + ready_ = true; + int32_t status = (result.permStateChangeType == 1) ? PERMISSION_GRANTED : PERMISSION_DENIED; + ASSERT_EQ(status, AccessTokenKit::VerifyAccessToken(result.tokenID, result.permissionName)); + } + + bool ready_; +}; + +/** + * @tc.name: PermStateChangeCallback001 + * @tc.desc: PermissionStateChangeCallback::PermStateChangeCallback function test. + * @tc.type: FUNC + * @tc.require: issueI61NS6 + */ +HWTEST_F(AccessTokenCoverageTest, PermStateChangeCallback001, TestSize.Level1) +{ + PermStateChangeInfo result = { + .permStateChangeType = 0, + .tokenID = 123, + .permissionName = "ohos.permission.CAMERA" + }; + + std::shared_ptr callbackPtr = nullptr; + std::shared_ptr callback = std::make_shared( + callbackPtr); + ASSERT_NE(callback, nullptr); + + callback->PermStateChangeCallback(result); + ASSERT_EQ(callback->customizedCallback_, nullptr); + callback->Stop(); +} + +class TestCallBack : public PermissionStateChangeCallbackStub { +public: + TestCallBack() = default; + virtual ~TestCallBack() = default; + + void PermStateChangeCallback(PermStateChangeInfo& result) + { + GTEST_LOG_(INFO) << "PermStateChangeCallback, tokenID is " << result.tokenID; + } +}; + +/** + * @tc.name: OnRemoteRequest001 + * @tc.desc: StateChangeCallbackStub::OnRemoteRequest function test + * @tc.type: FUNC + * @tc.require: issueI61A6M + */ +HWTEST_F(AccessTokenCoverageTest, OnRemoteRequest001, TestSize.Level1) +{ + PermStateChangeInfo info = { + .permStateChangeType = 0, + .tokenID = 123, + .permissionName = "ohos.permission.CAMERA" + }; + + TestCallBack callback; + PermissionStateChangeInfoParcel infoParcel; + infoParcel.changeInfo = info; + + OHOS::MessageParcel data; + std::string descriptor = "I don't know"; + data.WriteInterfaceToken(OHOS::Str8ToStr16(descriptor)); + ASSERT_EQ(true, data.WriteParcelable(&infoParcel)); + + OHOS::MessageParcel reply; + OHOS::MessageOption option(OHOS::MessageOption::TF_SYNC); + ASSERT_NE(0, + callback.OnRemoteRequest(static_cast(AccesstokenStateChangeInterfaceCode::PERMISSION_STATE_CHANGE), + data, reply, option)); // descriptor false + + ASSERT_EQ(true, data.WriteInterfaceToken(IPermissionStateCallback::GetDescriptor())); + ASSERT_EQ(true, data.WriteParcelable(&infoParcel)); + uint32_t code = 10; + ASSERT_NE(0, callback.OnRemoteRequest(code, data, reply, option)); // descriptor true + msgCode false +} + +/** + * @tc.name: CreatePermStateChangeCallback001 + * @tc.desc: AccessTokenManagerClient::CreatePermStateChangeCallback function test + * @tc.type: FUNC + * @tc.require: issueI61A6M + */ +HWTEST_F(AccessTokenCoverageTest, CreatePermStateChangeCallback001, TestSize.Level1) +{ + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.GET_SENSITIVE_PERMISSIONS"); + MockHapToken mock("CreatePermStateChangeCallback001", reqPerm, true); + + std::vector> callbackList; + + uint32_t times = 201; + for (uint32_t i = 0; i < times; i++) { + PermStateChangeScope scopeInfo; + scopeInfo.permList = {}; + scopeInfo.tokenIDs = {}; + auto callbackPtr = std::make_shared(scopeInfo); + callbackList.emplace_back(callbackPtr); + int32_t res = AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr); + + if (i == 200) { + EXPECT_EQ(AccessTokenError::ERR_CALLBACKS_EXCEED_LIMITATION, res); + break; + } + } + + for (uint32_t i = 0; i < 200; i++) { + ASSERT_EQ(0, AccessTokenKit::UnRegisterPermStateChangeCallback(callbackList[i])); + } + + std::shared_ptr customizedCb = nullptr; + AccessTokenKit::RegisterPermStateChangeCallback(customizedCb); // customizedCb is null +} + +/** + * @tc.name: InitProxy001 + * @tc.desc: AccessTokenManagerClient::InitProxy function test + * @tc.type: FUNC + * @tc.require: issueI61A6M + */ +HWTEST_F(AccessTokenCoverageTest, InitProxy001, TestSize.Level1) +{ + ASSERT_NE(nullptr, AccessTokenManagerClient::GetInstance().proxy_); + OHOS::sptr proxy = AccessTokenManagerClient::GetInstance().proxy_; // backup + AccessTokenManagerClient::GetInstance().proxy_ = nullptr; + ASSERT_EQ(nullptr, AccessTokenManagerClient::GetInstance().proxy_); + AccessTokenManagerClient::GetInstance().InitProxy(); // proxy_ is null + AccessTokenManagerClient::GetInstance().proxy_ = proxy; // recovery +} + +/** + * @tc.name: AllocHapToken001 + * @tc.desc: AccessTokenKit::AllocHapToken function test + * @tc.type: FUNC + * @tc.require: issueI61A6M + */ +HWTEST_F(AccessTokenCoverageTest, AllocHapToken001, TestSize.Level1) +{ + HapInfoParams info; + HapPolicyParams policy; + info.userID = -1; + AccessTokenKit::AllocHapToken(info, policy); + ASSERT_EQ(-1, info.userID); +} + +/** + * @tc.name: VerifyAccessToken005 + * @tc.desc: AccessTokenKit::VerifyAccessToken function test + * @tc.type: FUNC + * @tc.require: issueI61A6M + */ +HWTEST_F(AccessTokenCoverageTest, VerifyAccessToken005, TestSize.Level1) +{ + HapInfoParams info = { + .userID = TEST_USER_ID, + .bundleName = "accesstoken_test3", + .instIndex = 0, + .appIDDesc = "test3", + .apiVersion = DEFAULT_API_VERSION + }; + PermissionStateFull permState = { + .permissionName = "ohos.permission.GET_BUNDLE_INFO", + .isGeneral = true, + .resDeviceID = {"local3"}, + .grantStatus = {PermissionState::PERMISSION_GRANTED}, + .grantFlags = {1} + }; + + HapPolicyParams policy = { + .apl = APL_NORMAL, + .domain = "test.domain3", + .permStateList = {permState} + }; + + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ(RET_SUCCESS, TestCommon::AllocTestHapToken(info, policy, tokenIdEx)); + AccessTokenID callerTokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, callerTokenID); + AccessTokenID firstTokenID; + + // ret = PERMISSION_GRANTED + firstTokenID = 0 + std::string permissionName = "ohos.permission.GET_BUNDLE_INFO"; + firstTokenID = 0; + ASSERT_EQ(PermissionState::PERMISSION_GRANTED, AccessTokenKit::VerifyAccessToken( + callerTokenID, firstTokenID, permissionName, false)); + + firstTokenID = 1; + // ret = PERMISSION_GRANTED + firstTokenID != 0 + ASSERT_EQ(PermissionState::PERMISSION_DENIED, AccessTokenKit::VerifyAccessToken( + callerTokenID, firstTokenID, permissionName, false)); + TestCommon::DeleteTestHapToken(callerTokenID); + + callerTokenID = 0; + // ret = PERMISSION_DENIED + ASSERT_EQ(PermissionState::PERMISSION_DENIED, AccessTokenKit::VerifyAccessToken( + callerTokenID, firstTokenID, permissionName, false)); +} + +/** + * @tc.name: GetRenderTokenIDTest001 + * @tc.desc: TokenIdKit::GetRenderTokenID function test + * @tc.type: FUNC + * @tc.require: issueI7MOA1 + */ +HWTEST_F(AccessTokenCoverageTest, GetRenderTokenIDTest001, TestSize.Level1) +{ + uint64_t validTokenID = GetSelfTokenID(); + uint64_t retTokenId = validTokenID; + + retTokenId = TokenIdKit::GetRenderTokenID(validTokenID); + ASSERT_NE(retTokenId, validTokenID); + ASSERT_NE(retTokenId, INVALID_TOKENID); +} + +/** + * @tc.name: GetRenderTokenIDTest002 + * @tc.desc: TokenIdKit::GetRenderTokenID function test + * @tc.type: FUNC + * @tc.require: issueI7MOA1 + */ +HWTEST_F(AccessTokenCoverageTest, GetRenderTokenIDTest002, TestSize.Level1) +{ + uint64_t invalidTokenID = 0; + uint64_t retTokenId = 1; /* 1, for testing purposes */ + + retTokenId = TokenIdKit::GetRenderTokenID(invalidTokenID); + ASSERT_EQ(invalidTokenID, retTokenId); +} + +/** + * @tc.name: GetRenderTokenIDTest003 + * @tc.desc: AccessTokenKit::GetRenderTokenID function test + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AccessTokenCoverageTest, GetRenderTokenIDTest003, TestSize.Level1) +{ + uint64_t invalidTokenID = 0; + uint64_t retTokenId = 1; /* 1, for testing purposes */ + + retTokenId = AccessTokenKit::GetRenderTokenID(invalidTokenID); + ASSERT_EQ(invalidTokenID, retTokenId); +} + +#ifdef TOKEN_SYNC_ENABLE +namespace { +class TokenSyncCallbackStubTest : public TokenSyncCallbackStub { +public: + TokenSyncCallbackStubTest() = default; + virtual ~TokenSyncCallbackStubTest() = default; + + int32_t GetRemoteHapTokenInfo(const std::string& deviceID, AccessTokenID tokenID) override + { + return 0; + }; + int32_t DeleteRemoteHapTokenInfo(AccessTokenID tokenID) override + { + return 0; + }; + + int32_t UpdateRemoteHapTokenInfo(const HapTokenInfoForSync& tokenInfo) override + { + return 0; + }; +}; + +static const int32_t FAKE_SYNC_RET = 0xabcdef; +class TokenSyncCallbackImpl : public TokenSyncKitInterface { +public: + ~TokenSyncCallbackImpl() + {} + + int32_t GetRemoteHapTokenInfo(const std::string& deviceID, AccessTokenID tokenID) const override + { + LOGI(ATM_DOMAIN, ATM_TAG, "GetRemoteHapTokenInfo called."); + return FAKE_SYNC_RET; + }; + + int32_t DeleteRemoteHapTokenInfo(AccessTokenID tokenID) const override + { + LOGI(ATM_DOMAIN, ATM_TAG, "DeleteRemoteHapTokenInfo called."); + return FAKE_SYNC_RET; + }; + + int32_t UpdateRemoteHapTokenInfo(const HapTokenInfoForSync& tokenInfo) const override + { + LOGI(ATM_DOMAIN, ATM_TAG, "UpdateRemoteHapTokenInfo called."); + return FAKE_SYNC_RET; + }; +}; +}; + +/** + * @tc.name: TokenSyncCallbackStubTest001 + * @tc.desc: TokenSyncCallbackStub OnRemoteRequest deny test + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AccessTokenCoverageTest, TokenSyncCallbackStubTest001, TestSize.Level1) +{ + TokenSyncCallbackStubTest callback; + + OHOS::MessageParcel data; + std::string descriptor = "I don't know"; + data.WriteInterfaceToken(OHOS::Str8ToStr16(descriptor)); + + OHOS::MessageParcel reply; + OHOS::MessageOption option(OHOS::MessageOption::TF_SYNC); + EXPECT_EQ(ERROR_IPC_REQUEST_FAIL, + callback.OnRemoteRequest(static_cast(TokenSyncCallbackInterfaceCode::GET_REMOTE_HAP_TOKEN_INFO), + data, reply, option)); // descriptor false +} + +/** + * @tc.name: TokenSyncCallbackStubTest002 + * @tc.desc: TokenSyncCallbackStub OnRemoteRequest err code + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AccessTokenCoverageTest, TokenSyncCallbackStubTest002, TestSize.Level1) +{ + TokenSyncCallbackStubTest callback; + OHOS::MessageParcel data; + data.WriteInterfaceToken(ITokenSyncCallback::GetDescriptor()); + + OHOS::MessageParcel reply; + OHOS::MessageOption option(OHOS::MessageOption::TF_SYNC); + EXPECT_NE(0, callback.OnRemoteRequest(static_cast(0xff), // code false + data, reply, option)); +} + +/** + * @tc.name: TokenSyncCallbackStubTest003 + * @tc.desc: TokenSyncCallbackStub OnRemoteRequest deny call + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AccessTokenCoverageTest, TokenSyncCallbackStubTest003, TestSize.Level1) +{ + TokenSyncCallbackStubTest callback; + OHOS::MessageParcel data; + data.WriteInterfaceToken(ITokenSyncCallback::GetDescriptor()); + + OHOS::MessageParcel reply; + OHOS::MessageOption option(OHOS::MessageOption::TF_SYNC); + EXPECT_EQ(0, callback.OnRemoteRequest( + static_cast(TokenSyncCallbackInterfaceCode::GET_REMOTE_HAP_TOKEN_INFO), + data, reply, option)); + EXPECT_EQ(ERR_IDENTITY_CHECK_FAILED, reply.ReadInt32()); + + data.WriteInterfaceToken(ITokenSyncCallback::GetDescriptor()); + EXPECT_EQ(0, callback.OnRemoteRequest( + static_cast(TokenSyncCallbackInterfaceCode::DELETE_REMOTE_HAP_TOKEN_INFO), + data, reply, option)); + EXPECT_EQ(ERR_IDENTITY_CHECK_FAILED, reply.ReadInt32()); + + data.WriteInterfaceToken(ITokenSyncCallback::GetDescriptor()); + EXPECT_EQ(0, callback.OnRemoteRequest( + static_cast(TokenSyncCallbackInterfaceCode::UPDATE_REMOTE_HAP_TOKEN_INFO), + data, reply, option)); + EXPECT_EQ(ERR_IDENTITY_CHECK_FAILED, reply.ReadInt32()); +} + +/** + * @tc.name: TokenSyncCallbackStubTest004 + * @tc.desc: TokenSyncCallbackStub OnRemoteRequest normal call + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AccessTokenCoverageTest, TokenSyncCallbackStubTest004, TestSize.Level1) +{ + setuid(3020); // ACCESSTOKEN_UID + + TokenSyncCallbackStubTest callback; + OHOS::MessageParcel data; + OHOS::MessageParcel reply; + OHOS::MessageOption option(OHOS::MessageOption::TF_SYNC); + + data.WriteInterfaceToken(ITokenSyncCallback::GetDescriptor()); + data.WriteString("test deviceID"); // test deviceID + data.WriteUint32(0); // test tokenid + EXPECT_EQ(0, callback.OnRemoteRequest( + static_cast(TokenSyncCallbackInterfaceCode::GET_REMOTE_HAP_TOKEN_INFO), + data, reply, option)); + EXPECT_EQ(0, reply.ReadInt32()); + + data.WriteInterfaceToken(ITokenSyncCallback::GetDescriptor()); + data.WriteUint32(0); // test tokenid + EXPECT_EQ(0, callback.OnRemoteRequest( + static_cast(TokenSyncCallbackInterfaceCode::DELETE_REMOTE_HAP_TOKEN_INFO), + data, reply, option)); + EXPECT_EQ(0, reply.ReadInt32()); + + data.WriteInterfaceToken(ITokenSyncCallback::GetDescriptor()); + HapTokenInfoForSync info; + HapTokenInfoForSyncParcel tokenInfoParcel; + tokenInfoParcel.hapTokenInfoForSyncParams = info; + data.WriteParcelable(&tokenInfoParcel); + EXPECT_EQ(0, callback.OnRemoteRequest( + static_cast(TokenSyncCallbackInterfaceCode::UPDATE_REMOTE_HAP_TOKEN_INFO), + data, reply, option)); + EXPECT_EQ(0, reply.ReadInt32()); + setuid(0); // root uid +} + +/** + * @tc.name: TokenSyncCallbackTest001 + * @tc.desc: TokenSyncCallback inner call + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AccessTokenCoverageTest, TokenSyncCallbackTest001, TestSize.Level1) +{ + TokenSyncCallback callback(nullptr); + EXPECT_EQ(nullptr, callback.tokenSyncCallback_); // test input + + std::shared_ptr ptr = std::make_shared(); + std::shared_ptr callbackImpl = std::make_shared(ptr); + EXPECT_NE(nullptr, callbackImpl->tokenSyncCallback_); + EXPECT_EQ(FAKE_SYNC_RET, callbackImpl->GetRemoteHapTokenInfo("test", 0)); // test input + EXPECT_EQ(FAKE_SYNC_RET, callbackImpl->DeleteRemoteHapTokenInfo(0)); // test input + HapTokenInfoForSync info; + EXPECT_EQ(FAKE_SYNC_RET, callbackImpl->UpdateRemoteHapTokenInfo(info)); // test input +} +#endif // TOKEN_SYNC_ENABLE + +/** + * @tc.name: GetPermissionManagerInfo001 + * @tc.desc: + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AccessTokenCoverageTest, GetPermissionManagerInfo001, TestSize.Level1) +{ + PermissionGrantInfo info; + AccessTokenKit::GetPermissionManagerInfo(info); + ASSERT_EQ(false, info.grantBundleName.empty()); +} + +} // namespace AccessToken +} // namespace Security +} // namespace OHOS diff --git a/interfaces/innerkits/accesstoken/test/unittest/HapAttributeTest/user_policy_test.h b/interfaces/innerkits/accesstoken/test/unittest/Coverage/accesstoken_kit_coverage_test.h similarity index 81% rename from interfaces/innerkits/accesstoken/test/unittest/HapAttributeTest/user_policy_test.h rename to interfaces/innerkits/accesstoken/test/unittest/Coverage/accesstoken_kit_coverage_test.h index 98c5ab84067b0dca3bb040ea42803029b33de71b..e805813ddeeb1932996a13ea5a823d468f77d650 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/HapAttributeTest/user_policy_test.h +++ b/interfaces/innerkits/accesstoken/test/unittest/Coverage/accesstoken_kit_coverage_test.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024 Huawei Device Co., Ltd. + * Copyright (c) 2025 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 @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef USER_POLICY_TEST_H -#define USER_POLICY_TEST_H +#ifndef ACCESSTOKEN_KIT_COVERAGE_TEST_H +#define ACCESSTOKEN_KIT_COVERAGE_TEST_H #include @@ -26,7 +26,7 @@ namespace OHOS { namespace Security { namespace AccessToken { -class UserPolicyTest : public testing::Test { +class AccessTokenCoverageTest : public testing::Test { public: static void SetUpTestCase(); static void TearDownTestCase(); @@ -36,4 +36,4 @@ public: } // namespace AccessToken } // namespace Security } // namespace OHOS -#endif // USER_POLICY_TEST_H \ No newline at end of file +#endif // ACCESSTOKEN_KIT_COVERAGE_TEST_H diff --git a/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/alloc_local_token_id_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/alloc_local_token_id_test.cpp index d79656982359c59eeb8934327bcde36803a5d4f2..f4aa037bb6ddbbc5bddbec95b94aa5f6b15547f9 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/alloc_local_token_id_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/alloc_local_token_id_test.cpp @@ -20,8 +20,8 @@ #include "accesstoken_common_log.h" #include "access_token_error.h" #include "nativetoken_kit.h" -#include "token_setproc.h" #include "test_common.h" +#include "token_setproc.h" using namespace testing::ext; using namespace OHOS::Security::AccessToken; @@ -29,24 +29,18 @@ using namespace OHOS::Security::AccessToken; namespace { static const std::string TEST_BUNDLE_NAME = "ohos"; static const std::string TEST_PKG_NAME = "com.softbus.test"; -static AccessTokenID g_selfTokenId = 0; +static uint64_t g_selfTokenId = 0; +static AccessTokenID g_testTokenId = 0x20100000; HapTokenInfo g_baseInfo = { .ver = 1, .userID = 1, .bundleName = "com.ohos.access_token", .instIndex = 1, - .tokenID = 0x20100000, + .tokenID = g_testTokenId, .tokenAttr = 0 }; -void NativeTokenGet() -{ - uint32_t tokenId = AccessTokenKit::GetNativeTokenId("token_sync_service"); - ASSERT_NE(tokenId, INVALID_TOKENID); - EXPECT_EQ(0, SetSelfTokenID(tokenId)); -} - #ifdef TOKEN_SYNC_ENABLE static const int32_t FAKE_SYNC_RET = 0xabcdef; class TokenSyncCallbackImpl : public TokenSyncKitInterface { @@ -78,30 +72,35 @@ public: void AllocLocalTokenIDTest::SetUpTestCase() { g_selfTokenId = GetSelfTokenID(); - - NativeTokenGet(); - + TestCommon::SetTestEvironment(g_selfTokenId); #ifdef TOKEN_SYNC_ENABLE - std::shared_ptr ptrDmInitCallback = std::make_shared(); - int32_t res = DistributedHardware::DeviceManager::GetInstance().InitDeviceManager(TEST_PKG_NAME, ptrDmInitCallback); - ASSERT_EQ(res, RET_SUCCESS); + { + MockNativeToken mock("foundation"); + std::shared_ptr ptrDmInitCallback = std::make_shared(); + int32_t res = + DistributedHardware::DeviceManager::GetInstance().InitDeviceManager(TEST_PKG_NAME, ptrDmInitCallback); + ASSERT_EQ(res, RET_SUCCESS); + } #endif } void AllocLocalTokenIDTest::TearDownTestCase() { - SetSelfTokenID(g_selfTokenId); #ifdef TOKEN_SYNC_ENABLE - int32_t res = DistributedHardware::DeviceManager::GetInstance().UnInitDeviceManager(TEST_PKG_NAME); - ASSERT_EQ(res, RET_SUCCESS); + { + MockNativeToken mock("foundation"); + int32_t res = DistributedHardware::DeviceManager::GetInstance().UnInitDeviceManager(TEST_PKG_NAME); + ASSERT_EQ(res, RET_SUCCESS); + } #endif + EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId)); + TestCommon::ResetTestEvironment(); } void AllocLocalTokenIDTest::SetUp() { - selfTokenId_ = GetSelfTokenID(); - #ifdef TOKEN_SYNC_ENABLE + MockNativeToken mock("foundation"); DistributedHardware::DmDeviceInfo deviceInfo; int32_t res = DistributedHardware::DeviceManager::GetInstance().GetLocalDeviceInfo(TEST_PKG_NAME, deviceInfo); ASSERT_EQ(res, RET_SUCCESS); @@ -115,12 +114,11 @@ void AllocLocalTokenIDTest::SetUp() #endif LOGI(ATM_DOMAIN, ATM_TAG, "SetUp ok."); - setuid(0); } void AllocLocalTokenIDTest::TearDown() { - EXPECT_EQ(0, SetSelfTokenID(selfTokenId_)); + EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId)); udid_.clear(); networkId_.clear(); } @@ -128,15 +126,50 @@ void AllocLocalTokenIDTest::TearDown() #ifdef TOKEN_SYNC_ENABLE /** * @tc.name: AllocLocalTokenIDFuncTest001 - * @tc.desc: get already mapping tokenInfo, makesure ipc right + * @tc.desc: test call AllocLocalTokenID by hap token(permission denied) * @tc.type: FUNC * @tc.require:issue I5R4UF */ HWTEST_F(AllocLocalTokenIDTest, AllocLocalTokenIDFuncTest001, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "AllocLocalTokenIDFuncTest001 start."); + HapInfoParams infoParms = { + .userID = 1, + .bundleName = "GetHapTokenInfoFromRemoteTest", + .instIndex = 0, + .appIDDesc = "test.bundle", + .apiVersion = 8, + .appDistributionType = "enterprise_mdm" + }; + + HapPolicyParams policyPrams = { + .apl = APL_NORMAL, + .domain = "test.domain", + }; + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ(RET_SUCCESS, TestCommon::AllocTestHapToken(infoParms, policyPrams, tokenIdEx)); + AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(tokenId, INVALID_TOKENID); + EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); // set self hap token + + AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, g_testTokenId); + EXPECT_EQ(mapID, 0); + + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenId)); +} + +/** + * @tc.name: AllocLocalTokenIDFuncTest002 + * @tc.desc: get already mapping tokenInfo, makesure ipc right, by native token(permission pass) + * @tc.type: FUNC + * @tc.require:issue I5R4UF + */ +HWTEST_F(AllocLocalTokenIDTest, AllocLocalTokenIDFuncTest002, TestSize.Level1) +{ + LOGI(ATM_DOMAIN, ATM_TAG, "AllocLocalTokenIDFuncTest002 start."); + MockNativeToken mock("token_sync_service"); std::string deviceID1 = udid_; - AccessTokenKit::DeleteRemoteToken(deviceID1, 0x20100000); + AccessTokenKit::DeleteRemoteToken(deviceID1, g_testTokenId); PermissionStatus infoManagerTestState_1 = { .permissionName = "ohos.permission.test1", .grantStatus = PermissionState::PERMISSION_GRANTED, @@ -152,7 +185,7 @@ HWTEST_F(AllocLocalTokenIDTest, AllocLocalTokenIDFuncTest001, TestSize.Level1) int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID1, remoteTokenInfo1); ASSERT_EQ(ret, RET_SUCCESS); - AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000); + AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, g_testTokenId); ASSERT_NE(mapID, 0); } #endif \ No newline at end of file diff --git a/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/alloc_local_token_id_test.h b/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/alloc_local_token_id_test.h index c84bdbcb5118e6bee19e18330a1309f5edc74d88..ee0ca0ee6da34ff1b7c0f3ca2a164c0540cd0f11 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/alloc_local_token_id_test.h +++ b/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/alloc_local_token_id_test.h @@ -42,7 +42,6 @@ public: void SetUp(); void TearDown(); - uint64_t selfTokenId_; std::string udid_; std::string networkId_; }; diff --git a/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/delete_remote_device_tokens_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/delete_remote_device_tokens_test.cpp index 150a9f163273661ac8fa51efc7f3c3bf3c813d02..558f809a3c00a2ca08c233a15cd0178996a5e137 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/delete_remote_device_tokens_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/delete_remote_device_tokens_test.cpp @@ -20,6 +20,7 @@ #include "accesstoken_common_log.h" #include "access_token_error.h" #include "nativetoken_kit.h" +#include "test_common.h" #include "token_setproc.h" #include "test_common.h" @@ -29,24 +30,19 @@ using namespace OHOS::Security::AccessToken; namespace { static const std::string TEST_BUNDLE_NAME = "ohos"; static const std::string TEST_PKG_NAME = "com.softbus.test"; -static AccessTokenID g_selfTokenId = 0; +static uint64_t g_selfTokenId = 0; +static AccessTokenID g_testTokenId1 = 0x20100000; +static AccessTokenID g_testTokenId2 = 0x20100001; HapTokenInfo g_baseInfo = { .ver = 1, .userID = 1, .bundleName = "com.ohos.access_token", .instIndex = 1, - .tokenID = 0x20100000, + .tokenID = g_testTokenId1, .tokenAttr = 0 }; -void NativeTokenGet() -{ - uint32_t tokenId = AccessTokenKit::GetNativeTokenId("token_sync_service"); - ASSERT_NE(tokenId, INVALID_TOKENID); - EXPECT_EQ(0, SetSelfTokenID(tokenId)); -} - #ifdef TOKEN_SYNC_ENABLE static const int32_t FAKE_SYNC_RET = 0xabcdef; class TokenSyncCallbackImpl : public TokenSyncKitInterface { @@ -78,30 +74,36 @@ public: void DeleteRemoteDeviceTokensTest::SetUpTestCase() { g_selfTokenId = GetSelfTokenID(); - - NativeTokenGet(); + TestCommon::SetTestEvironment(g_selfTokenId); #ifdef TOKEN_SYNC_ENABLE - std::shared_ptr ptrDmInitCallback = std::make_shared(); - int32_t res = DistributedHardware::DeviceManager::GetInstance().InitDeviceManager(TEST_PKG_NAME, ptrDmInitCallback); - ASSERT_EQ(res, RET_SUCCESS); + { + MockNativeToken mock("foundation"); + std::shared_ptr ptrDmInitCallback = std::make_shared(); + int32_t res = + DistributedHardware::DeviceManager::GetInstance().InitDeviceManager(TEST_PKG_NAME, ptrDmInitCallback); + ASSERT_EQ(res, RET_SUCCESS); + } #endif } void DeleteRemoteDeviceTokensTest::TearDownTestCase() { - SetSelfTokenID(g_selfTokenId); #ifdef TOKEN_SYNC_ENABLE - int32_t res = DistributedHardware::DeviceManager::GetInstance().UnInitDeviceManager(TEST_PKG_NAME); - ASSERT_EQ(res, RET_SUCCESS); + { + MockNativeToken mock("foundation"); + int32_t res = DistributedHardware::DeviceManager::GetInstance().UnInitDeviceManager(TEST_PKG_NAME); + ASSERT_EQ(res, RET_SUCCESS); + } #endif + EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId)); + TestCommon::ResetTestEvironment(); } void DeleteRemoteDeviceTokensTest::SetUp() { - selfTokenId_ = GetSelfTokenID(); - #ifdef TOKEN_SYNC_ENABLE + MockNativeToken mock("foundation"); DistributedHardware::DmDeviceInfo deviceInfo; int32_t res = DistributedHardware::DeviceManager::GetInstance().GetLocalDeviceInfo(TEST_PKG_NAME, deviceInfo); ASSERT_EQ(res, RET_SUCCESS); @@ -113,14 +115,11 @@ void DeleteRemoteDeviceTokensTest::SetUp() ASSERT_EQ(res, RET_SUCCESS); ASSERT_NE(udid_, ""); #endif - LOGI(ATM_DOMAIN, ATM_TAG, "SetUp ok."); - setuid(0); } void DeleteRemoteDeviceTokensTest::TearDown() { - EXPECT_EQ(0, SetSelfTokenID(selfTokenId_)); udid_.clear(); networkId_.clear(); } @@ -134,10 +133,11 @@ void DeleteRemoteDeviceTokensTest::TearDown() */ HWTEST_F(DeleteRemoteDeviceTokensTest, DeleteRemoteDeviceTokensFuncTest001, TestSize.Level1) { + MockNativeToken mock("token_sync_service"); LOGI(ATM_DOMAIN, ATM_TAG, "DeleteRemoteDeviceTokensFuncTest001 start."); std::string deviceID1 = udid_; - AccessTokenKit::DeleteRemoteToken(deviceID1, 0x20100000); - AccessTokenKit::DeleteRemoteToken(deviceID1, 0x20100001); + AccessTokenKit::DeleteRemoteToken(deviceID1, g_testTokenId1); + AccessTokenKit::DeleteRemoteToken(deviceID1, g_testTokenId2); PermissionStatus infoManagerTestState4 = { .permissionName = "ohos.permission.test1", .grantStatus = PermissionState::PERMISSION_GRANTED, @@ -154,14 +154,14 @@ HWTEST_F(DeleteRemoteDeviceTokensTest, DeleteRemoteDeviceTokensFuncTest001, Test ASSERT_EQ(ret, RET_SUCCESS); HapTokenInfoForSync remoteTokenInfo2 = remoteTokenInfo1; - remoteTokenInfo2.baseInfo.tokenID = 0x20100001; + remoteTokenInfo2.baseInfo.tokenID = g_testTokenId2; remoteTokenInfo2.baseInfo.bundleName = "com.ohos.access_token1"; ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID1, remoteTokenInfo2); ASSERT_EQ(ret, RET_SUCCESS); - AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000); + AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, g_testTokenId1); ASSERT_NE(mapID, 0); - AccessTokenID mapID1 = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100001); + AccessTokenID mapID1 = AccessTokenKit::AllocLocalTokenID(networkId_, g_testTokenId2); ASSERT_NE(mapID1, 0); ret = AccessTokenKit::DeleteRemoteDeviceTokens(deviceID1); @@ -182,10 +182,11 @@ HWTEST_F(DeleteRemoteDeviceTokensTest, DeleteRemoteDeviceTokensFuncTest001, Test */ HWTEST_F(DeleteRemoteDeviceTokensTest, DeleteRemoteDeviceTokensFuncTest002, TestSize.Level1) { + MockNativeToken mock("token_sync_service"); LOGI(ATM_DOMAIN, ATM_TAG, "DeleteRemoteDeviceTokensFuncTest002 start."); std::string deviceID2 = udid_; - AccessTokenKit::DeleteRemoteToken(deviceID2, 0x20100000); - AccessTokenKit::DeleteRemoteToken(deviceID2, 0x20100001); + AccessTokenKit::DeleteRemoteToken(deviceID2, g_testTokenId1); + AccessTokenKit::DeleteRemoteToken(deviceID2, g_testTokenId2); PermissionStatus infoManagerTestState2 = { .permissionName = "ohos.permission.test1", .grantStatus = PermissionState::PERMISSION_GRANTED, @@ -202,33 +203,33 @@ HWTEST_F(DeleteRemoteDeviceTokensTest, DeleteRemoteDeviceTokensFuncTest002, Test ASSERT_EQ(ret, RET_SUCCESS); HapTokenInfoForSync remoteTokenInfo1 = remoteTokenInfo2; - remoteTokenInfo1.baseInfo.tokenID = 0x20100001; + remoteTokenInfo1.baseInfo.tokenID = g_testTokenId2; remoteTokenInfo1.baseInfo.bundleName = "com.ohos.access_token1"; ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID2, remoteTokenInfo1); ASSERT_EQ(ret, RET_SUCCESS); - AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000); + AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, g_testTokenId1); ASSERT_NE(mapID, 0); - AccessTokenID mapID1 = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100001); + AccessTokenID mapID1 = AccessTokenKit::AllocLocalTokenID(networkId_, g_testTokenId2); ASSERT_NE(mapID1, 0); ret = AccessTokenKit::DeleteRemoteDeviceTokens("1111111"); ASSERT_NE(ret, RET_SUCCESS); - AccessTokenKit::DeleteRemoteToken(deviceID2, 0x20100000); - AccessTokenKit::DeleteRemoteToken(deviceID2, 0x20100001); + AccessTokenKit::DeleteRemoteToken(deviceID2, g_testTokenId1); + AccessTokenKit::DeleteRemoteToken(deviceID2, g_testTokenId2); } /** * @tc.name: DeleteRemoteDeviceTokensAbnormalTest001 - * @tc.desc: DeleteRemoteDeviceTokens with no permission + * @tc.desc: call DeleteRemoteDeviceTokens with other native process(not accesstoken uid, permission denied) * @tc.type: FUNC * @tc.require: */ HWTEST_F(DeleteRemoteDeviceTokensTest, DeleteRemoteDeviceTokensAbnormalTest001, TestSize.Level1) { - EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId)); LOGI(ATM_DOMAIN, ATM_TAG, "DeleteRemoteDeviceTokensAbnormalTest001 start."); + SetSelfTokenID(g_selfTokenId); std::string device = "device"; ASSERT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, AccessTokenKit::DeleteRemoteDeviceTokens(device)); } diff --git a/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/delete_remote_device_tokens_test.h b/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/delete_remote_device_tokens_test.h index afd4167099cb29020510c5fac0f90936eb45300e..e68b8294e2973e2febbbf3991c70e7dd653cf053 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/delete_remote_device_tokens_test.h +++ b/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/delete_remote_device_tokens_test.h @@ -42,7 +42,6 @@ public: void SetUp(); void TearDown(); - uint64_t selfTokenId_; std::string udid_; std::string networkId_; }; diff --git a/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/delete_remote_token_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/delete_remote_token_test.cpp index f80754b116012f0246cfea4b84d0a491619a060e..e3f7cabce6375244384c3345176399753fd19467 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/delete_remote_token_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/delete_remote_token_test.cpp @@ -20,8 +20,8 @@ #include "accesstoken_common_log.h" #include "access_token_error.h" #include "nativetoken_kit.h" -#include "token_setproc.h" #include "test_common.h" +#include "token_setproc.h" using namespace testing::ext; using namespace OHOS::Security::AccessToken; @@ -29,26 +29,19 @@ using namespace OHOS::Security::AccessToken; namespace { static const std::string TEST_BUNDLE_NAME = "ohos"; static const std::string TEST_PKG_NAME = "com.softbus.test"; -static AccessTokenID g_selfTokenId = 0; - +static uint64_t g_selfTokenId = 0; HapInfoParams g_infoManagerTestInfoParms = TestCommon::GetInfoManagerTestInfoParms(); +static AccessTokenID g_testTokenId = 0x20100000; HapTokenInfo g_baseInfo = { .ver = 1, .userID = 1, .bundleName = "com.ohos.access_token", .instIndex = 1, - .tokenID = 0x20100000, + .tokenID = g_testTokenId, .tokenAttr = 0 }; -void NativeTokenGet() -{ - uint32_t tokenId = AccessTokenKit::GetNativeTokenId("token_sync_service"); - ASSERT_NE(tokenId, INVALID_TOKENID); - EXPECT_EQ(0, SetSelfTokenID(tokenId)); -} - #ifdef TOKEN_SYNC_ENABLE static const int32_t FAKE_SYNC_RET = 0xabcdef; class TokenSyncCallbackImpl : public TokenSyncKitInterface { @@ -80,41 +73,41 @@ public: void DeleteRemoteTokenTest::SetUpTestCase() { g_selfTokenId = GetSelfTokenID(); + TestCommon::SetTestEvironment(g_selfTokenId); // make test case clean - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - NativeTokenGet(); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(g_infoManagerTestInfoParms.userID, + g_infoManagerTestInfoParms.bundleName, g_infoManagerTestInfoParms.instIndex); + TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID); #ifdef TOKEN_SYNC_ENABLE - std::shared_ptr ptrDmInitCallback = std::make_shared(); - int32_t res = DistributedHardware::DeviceManager::GetInstance().InitDeviceManager(TEST_PKG_NAME, ptrDmInitCallback); - ASSERT_EQ(res, RET_SUCCESS); + { + MockNativeToken mock("foundation"); + std::shared_ptr ptrDmInitCallback = std::make_shared(); + int32_t res = + DistributedHardware::DeviceManager::GetInstance().InitDeviceManager(TEST_PKG_NAME, ptrDmInitCallback); + ASSERT_EQ(res, RET_SUCCESS); + } #endif } void DeleteRemoteTokenTest::TearDownTestCase() { - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - SetSelfTokenID(g_selfTokenId); #ifdef TOKEN_SYNC_ENABLE - int32_t res = DistributedHardware::DeviceManager::GetInstance().UnInitDeviceManager(TEST_PKG_NAME); - ASSERT_EQ(res, RET_SUCCESS); + { + MockNativeToken mock("foundation"); + int32_t res = DistributedHardware::DeviceManager::GetInstance().UnInitDeviceManager(TEST_PKG_NAME); + ASSERT_EQ(res, RET_SUCCESS); + } #endif + EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId)); + TestCommon::ResetTestEvironment(); } void DeleteRemoteTokenTest::SetUp() { - selfTokenId_ = GetSelfTokenID(); - #ifdef TOKEN_SYNC_ENABLE + MockNativeToken mock("foundation"); DistributedHardware::DmDeviceInfo deviceInfo; int32_t res = DistributedHardware::DeviceManager::GetInstance().GetLocalDeviceInfo(TEST_PKG_NAME, deviceInfo); ASSERT_EQ(res, RET_SUCCESS); @@ -128,12 +121,11 @@ void DeleteRemoteTokenTest::SetUp() #endif LOGI(ATM_DOMAIN, ATM_TAG, "SetUp ok."); - setuid(0); } void DeleteRemoteTokenTest::TearDown() { - EXPECT_EQ(0, SetSelfTokenID(selfTokenId_)); + EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId)); udid_.clear(); networkId_.clear(); } @@ -148,14 +140,16 @@ void DeleteRemoteTokenTest::TearDown() HWTEST_F(DeleteRemoteTokenTest, DeleteRemoteTokenAbnormalTest001, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "DeleteRemoteTokenAbnormalTest001 start."); + MockNativeToken mock("token_sync_service"); std::string deviceId = "device"; - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); + AccessTokenID tokenID = INVALID_TOKENID; + + // invalid device int res = AccessTokenKit::DeleteRemoteToken("", tokenID); ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, res); + // invalid tokenId res = AccessTokenKit::DeleteRemoteToken(deviceId, tokenID); ASSERT_NE(RET_SUCCESS, res); } @@ -169,7 +163,6 @@ HWTEST_F(DeleteRemoteTokenTest, DeleteRemoteTokenAbnormalTest001, TestSize.Level HWTEST_F(DeleteRemoteTokenTest, DeleteRemoteTokenAbnormalTest002, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "DeleteRemoteTokenAbnormalTest002 start."); - EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId)); std::string device = "device"; AccessTokenID tokenId = 123; ASSERT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, AccessTokenKit::DeleteRemoteToken(device, tokenId)); @@ -183,9 +176,10 @@ HWTEST_F(DeleteRemoteTokenTest, DeleteRemoteTokenAbnormalTest002, TestSize.Level */ HWTEST_F(DeleteRemoteTokenTest, DeleteRemoteTokenFuncTest001, TestSize.Level1) { + MockNativeToken mock("token_sync_service"); LOGI(ATM_DOMAIN, ATM_TAG, "DeleteRemoteTokenFuncTest001 start."); std::string deviceID1 = udid_; - AccessTokenKit::DeleteRemoteToken(deviceID1, 0x20100000); + AccessTokenKit::DeleteRemoteToken(deviceID1, g_testTokenId); PermissionStatus infoManagerTestState_3 = { .permissionName = "ohos.permission.test1", .grantStatus = PermissionState::PERMISSION_GRANTED, @@ -201,14 +195,14 @@ HWTEST_F(DeleteRemoteTokenTest, DeleteRemoteTokenFuncTest001, TestSize.Level1) int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID1, remoteTokenInfo11); ASSERT_EQ(ret, RET_SUCCESS); - AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000); + AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, g_testTokenId); ASSERT_NE(mapID, 0); HapTokenInfo info; ret = AccessTokenKit::GetHapTokenInfo(mapID, info); ASSERT_EQ(ret, RET_SUCCESS); - ret = AccessTokenKit::DeleteRemoteToken(deviceID1, 0x20100000); + ret = AccessTokenKit::DeleteRemoteToken(deviceID1, g_testTokenId); ASSERT_EQ(ret, RET_SUCCESS); ret = AccessTokenKit::GetHapTokenInfo(mapID, info); @@ -223,9 +217,10 @@ HWTEST_F(DeleteRemoteTokenTest, DeleteRemoteTokenFuncTest001, TestSize.Level1) */ HWTEST_F(DeleteRemoteTokenTest, DeleteRemoteTokenFuncTest002, TestSize.Level1) { + MockNativeToken mock("token_sync_service"); LOGI(ATM_DOMAIN, ATM_TAG, "DeleteRemoteTokenFuncTest002 start."); std::string deviceID2 = udid_; - AccessTokenKit::DeleteRemoteToken(deviceID2, 0x20100000); + AccessTokenKit::DeleteRemoteToken(deviceID2, g_testTokenId); PermissionStatus infoManagerTestState_2 = { .permissionName = "ohos.permission.test1", .grantStatus = PermissionState::PERMISSION_GRANTED, @@ -241,7 +236,7 @@ HWTEST_F(DeleteRemoteTokenTest, DeleteRemoteTokenFuncTest002, TestSize.Level1) int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID2, remoteTokenInfo2); ASSERT_EQ(ret, RET_SUCCESS); - AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000); + AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, g_testTokenId); ASSERT_NE(mapID, 0); HapTokenInfo info; @@ -254,7 +249,7 @@ HWTEST_F(DeleteRemoteTokenTest, DeleteRemoteTokenFuncTest002, TestSize.Level1) // deviceID is wrong std::string wrongStr(10241, 'x'); deviceID2 = wrongStr; - ret = AccessTokenKit::DeleteRemoteToken(deviceID2, 0x20100000); + ret = AccessTokenKit::DeleteRemoteToken(deviceID2, g_testTokenId); ASSERT_NE(ret, RET_SUCCESS); } @@ -266,11 +261,12 @@ HWTEST_F(DeleteRemoteTokenTest, DeleteRemoteTokenFuncTest002, TestSize.Level1) */ HWTEST_F(DeleteRemoteTokenTest, DeleteRemoteTokenFuncTest003, TestSize.Level1) { + MockNativeToken mock("token_sync_service"); LOGI(ATM_DOMAIN, ATM_TAG, "DeleteRemoteTokenFuncTest003 start."); std::string deviceID3 = udid_; - AccessTokenKit::DeleteRemoteToken(deviceID3, 0x20100000); + AccessTokenKit::DeleteRemoteToken(deviceID3, g_testTokenId); - int ret = AccessTokenKit::DeleteRemoteToken(deviceID3, 0x20100000); + int ret = AccessTokenKit::DeleteRemoteToken(deviceID3, g_testTokenId); ASSERT_NE(ret, RET_SUCCESS); } #endif \ No newline at end of file diff --git a/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/delete_remote_token_test.h b/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/delete_remote_token_test.h index 24085e0187e877bd30e6fa8768c3edde1d10dc6f..bac0efc239f8d56b91824ff5b0f5a9ce382bd067 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/delete_remote_token_test.h +++ b/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/delete_remote_token_test.h @@ -41,7 +41,6 @@ public: void SetUp(); void TearDown(); - uint64_t selfTokenId_; std::string udid_; std::string networkId_; }; diff --git a/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/get_hap_token_info_from_remote_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/get_hap_token_info_from_remote_test.cpp index b6431bb8cc175a8a129098ef4f332491f383c602..a7a1826adbbf244666c05d19c018aafb11c2b295 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/get_hap_token_info_from_remote_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/get_hap_token_info_from_remote_test.cpp @@ -20,8 +20,8 @@ #include "accesstoken_common_log.h" #include "access_token_error.h" #include "nativetoken_kit.h" -#include "token_setproc.h" #include "test_common.h" +#include "token_setproc.h" using namespace testing::ext; using namespace OHOS::Security::AccessToken; @@ -29,7 +29,7 @@ using namespace OHOS::Security::AccessToken; namespace { static const std::string TEST_BUNDLE_NAME = "ohos"; static const std::string TEST_PKG_NAME = "com.softbus.test"; -static AccessTokenID g_selfTokenId = 0; +static uint64_t g_selfTokenId = 0; HapInfoParams g_infoManagerTestInfoParms = TestCommon::GetInfoManagerTestInfoParms(); HapPolicyParams g_infoManagerTestPolicyPrams = TestCommon::GetInfoManagerTestPolicyPrams(); @@ -43,13 +43,6 @@ HapTokenInfo g_baseInfo = { .tokenAttr = 0 }; -void NativeTokenGet() -{ - uint32_t tokenId = AccessTokenKit::GetNativeTokenId("token_sync_service"); - ASSERT_NE(tokenId, INVALID_TOKENID); - EXPECT_EQ(0, SetSelfTokenID(tokenId)); -} - #ifdef TOKEN_SYNC_ENABLE static const int32_t FAKE_SYNC_RET = 0xabcdef; class TokenSyncCallbackImpl : public TokenSyncKitInterface { @@ -81,41 +74,45 @@ public: void GetHapTokenInfoFromRemoteTest::SetUpTestCase() { g_selfTokenId = GetSelfTokenID(); + TestCommon::SetTestEvironment(g_selfTokenId); // make test case clean - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - NativeTokenGet(); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(g_infoManagerTestInfoParms.userID, + g_infoManagerTestInfoParms.bundleName, g_infoManagerTestInfoParms.instIndex); + TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID); #ifdef TOKEN_SYNC_ENABLE - std::shared_ptr ptrDmInitCallback = std::make_shared(); - int32_t res = DistributedHardware::DeviceManager::GetInstance().InitDeviceManager(TEST_PKG_NAME, ptrDmInitCallback); - ASSERT_EQ(res, RET_SUCCESS); + { + MockNativeToken mock("foundation"); + std::shared_ptr ptrDmInitCallback = std::make_shared(); + int32_t res = + DistributedHardware::DeviceManager::GetInstance().InitDeviceManager(TEST_PKG_NAME, ptrDmInitCallback); + ASSERT_EQ(res, RET_SUCCESS); + } #endif } void GetHapTokenInfoFromRemoteTest::TearDownTestCase() { - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(g_infoManagerTestInfoParms.userID, + g_infoManagerTestInfoParms.bundleName, g_infoManagerTestInfoParms.instIndex); + TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID); - SetSelfTokenID(g_selfTokenId); #ifdef TOKEN_SYNC_ENABLE - int32_t res = DistributedHardware::DeviceManager::GetInstance().UnInitDeviceManager(TEST_PKG_NAME); - ASSERT_EQ(res, RET_SUCCESS); + { + MockNativeToken mock("foundation"); + int32_t res = DistributedHardware::DeviceManager::GetInstance().UnInitDeviceManager(TEST_PKG_NAME); + ASSERT_EQ(res, RET_SUCCESS); + } #endif + EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId)); + TestCommon::ResetTestEvironment(); } void GetHapTokenInfoFromRemoteTest::SetUp() { - selfTokenId_ = GetSelfTokenID(); - #ifdef TOKEN_SYNC_ENABLE + MockNativeToken mock("foundation"); DistributedHardware::DmDeviceInfo deviceInfo; int32_t res = DistributedHardware::DeviceManager::GetInstance().GetLocalDeviceInfo(TEST_PKG_NAME, deviceInfo); ASSERT_EQ(res, RET_SUCCESS); @@ -129,12 +126,11 @@ void GetHapTokenInfoFromRemoteTest::SetUp() #endif LOGI(ATM_DOMAIN, ATM_TAG, "SetUp ok."); - setuid(0); } void GetHapTokenInfoFromRemoteTest::TearDown() { - EXPECT_EQ(0, SetSelfTokenID(selfTokenId_)); + EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId)); udid_.clear(); networkId_.clear(); } @@ -149,22 +145,22 @@ void GetHapTokenInfoFromRemoteTest::TearDown() HWTEST_F(GetHapTokenInfoFromRemoteTest, GetHapTokenInfoFromRemoteFuncTest001, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "GetHapTokenInfoFromRemoteFuncTest001 start."); + AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); + ASSERT_EQ(RET_SUCCESS, TestCommon::AllocTestHapToken( + g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams, tokenIdEx)); AccessTokenID localTokenID = tokenIdEx.tokenIdExStruct.tokenID; + MockNativeToken mock("token_sync_service"); + HapTokenInfoForSync infoSync; int ret = AccessTokenKit::GetHapTokenInfoFromRemote(localTokenID, infoSync); ASSERT_EQ(ret, RET_SUCCESS); ASSERT_EQ(infoSync.permStateList.size(), static_cast(2)); ASSERT_EQ(infoSync.permStateList[0].permissionName, g_infoManagerTestPolicyPrams.permStateList[0].permissionName); - ASSERT_EQ(infoSync.permStateList[0].grantFlag, g_infoManagerTestPolicyPrams.permStateList[0].grantFlags[0]); - ASSERT_EQ(infoSync.permStateList[0].grantStatus, g_infoManagerTestPolicyPrams.permStateList[0].grantStatus[0]); ASSERT_EQ(infoSync.permStateList[1].permissionName, g_infoManagerTestPolicyPrams.permStateList[1].permissionName); - ASSERT_EQ(infoSync.permStateList[1].grantFlag, g_infoManagerTestPolicyPrams.permStateList[1].grantFlags[0]); - ASSERT_EQ(infoSync.permStateList[1].grantStatus, g_infoManagerTestPolicyPrams.permStateList[1].grantStatus[0]); ASSERT_EQ(infoSync.baseInfo.bundleName, g_infoManagerTestInfoParms.bundleName); ASSERT_EQ(infoSync.baseInfo.userID, g_infoManagerTestInfoParms.userID); @@ -173,7 +169,7 @@ HWTEST_F(GetHapTokenInfoFromRemoteTest, GetHapTokenInfoFromRemoteFuncTest001, Te ASSERT_EQ(infoSync.baseInfo.tokenID, localTokenID); ASSERT_EQ(infoSync.baseInfo.tokenAttr, 0); - AccessTokenKit::DeleteToken(localTokenID); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(localTokenID)); } /** @@ -184,6 +180,7 @@ HWTEST_F(GetHapTokenInfoFromRemoteTest, GetHapTokenInfoFromRemoteFuncTest001, Te */ HWTEST_F(GetHapTokenInfoFromRemoteTest, GetHapTokenInfoFromRemoteFuncTest002, TestSize.Level1) { + MockNativeToken mock("token_sync_service"); LOGI(ATM_DOMAIN, ATM_TAG, "GetHapTokenInfoFromRemoteFuncTest002 start."); std::string deviceID2 = udid_; AccessTokenKit::DeleteRemoteToken(deviceID2, 0x20100000); diff --git a/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/get_hap_token_info_from_remote_test.h b/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/get_hap_token_info_from_remote_test.h index 751bafa9ef39d2fbe749cba303caf029a6e1edfd..5ec4937bdb241e255be50f4d2c7d624dd94d26b0 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/get_hap_token_info_from_remote_test.h +++ b/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/get_hap_token_info_from_remote_test.h @@ -42,7 +42,6 @@ public: void SetUp(); void TearDown(); - uint64_t selfTokenId_; std::string udid_; std::string networkId_; }; diff --git a/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/get_remote_native_tokenid_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/get_remote_native_tokenid_test.cpp index ebb724c43780b6acdc9ef707aa5de5684b8421e3..ea33192e174a546e2c03e509d938769f092cd9a7 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/get_remote_native_tokenid_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/get_remote_native_tokenid_test.cpp @@ -17,6 +17,7 @@ #include "accesstoken_kit.h" #include "accesstoken_common_log.h" #include "access_token_error.h" +#include "test_common.h" #include "token_setproc.h" #ifdef TOKEN_SYNC_ENABLE #include "token_sync_kit_interface.h" @@ -25,18 +26,17 @@ using namespace testing::ext; using namespace OHOS::Security::AccessToken; namespace { -static AccessTokenID g_selfTokenId = 0; -static AccessTokenIDEx g_testTokenIDEx = {0}; -static int32_t g_selfUid; +static uint64_t g_selfTokenId = 0; +static AccessTokenID g_testTokenID = 0; -static HapPolicyParams g_PolicyPrams = { +static HapPolicyParams g_policyPrams = { .apl = APL_NORMAL, .domain = "test.domain", }; -static HapInfoParams g_InfoParms = { +static HapInfoParams g_infoParms = { .userID = 1, - .bundleName = "ohos.test.bundle", + .bundleName = "GetRemoteNativeTokenIDTest", .instIndex = 0, .appIDDesc = "test.bundle", .isSystemApp = true @@ -67,35 +67,33 @@ using namespace testing::ext; void GetRemoteNativeTokenIDTest::SetUpTestCase() { g_selfTokenId = GetSelfTokenID(); - g_selfUid = getuid(); + TestCommon::SetTestEvironment(g_selfTokenId); } void GetRemoteNativeTokenIDTest::TearDownTestCase() { - setuid(g_selfUid); EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId)); + TestCommon::ResetTestEvironment(); GTEST_LOG_(INFO) << "PermStateChangeCallback, tokenID is " << GetSelfTokenID(); GTEST_LOG_(INFO) << "PermStateChangeCallback, uid is " << getuid(); } void GetRemoteNativeTokenIDTest::SetUp() { - AccessTokenKit::AllocHapToken(g_InfoParms, g_PolicyPrams); + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ(RET_SUCCESS, TestCommon::AllocTestHapToken(g_infoParms, g_policyPrams, tokenIdEx)); - g_testTokenIDEx = AccessTokenKit::GetHapTokenIDEx(g_InfoParms.userID, - g_InfoParms.bundleName, - g_InfoParms.instIndex); - ASSERT_NE(INVALID_TOKENID, g_testTokenIDEx.tokenIDEx); - setuid(g_selfUid); - EXPECT_EQ(0, SetSelfTokenID(g_testTokenIDEx.tokenIDEx)); - setuid(1234); // 1234: UID + g_testTokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, g_testTokenID); + EXPECT_EQ(0, SetSelfTokenID(g_testTokenID)); } void GetRemoteNativeTokenIDTest::TearDown() { - setuid(g_selfUid); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle( + g_infoParms.userID, g_infoParms.bundleName, g_infoParms.instIndex); + TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID); EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId)); - setuid(g_selfUid); } #ifdef TOKEN_SYNC_ENABLE /** diff --git a/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/register_token_sync_callback_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/register_token_sync_callback_test.cpp index 6706bb5fa339ef6ee862154670629acd9510973a..16e49bd206ef593c6f5c31e0e8878876a8b51736 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/register_token_sync_callback_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/register_token_sync_callback_test.cpp @@ -20,8 +20,8 @@ #include "accesstoken_common_log.h" #include "access_token_error.h" #include "nativetoken_kit.h" -#include "token_setproc.h" #include "test_common.h" +#include "token_setproc.h" using namespace testing::ext; using namespace OHOS::Security::AccessToken; @@ -29,24 +29,18 @@ using namespace OHOS::Security::AccessToken; namespace { static const std::string TEST_BUNDLE_NAME = "ohos"; static const std::string TEST_PKG_NAME = "com.softbus.test"; -static AccessTokenID g_selfTokenId = 0; +static uint64_t g_selfTokenId = 0; +static AccessTokenID g_testTokenId = 0x20100000; HapTokenInfo g_baseInfo = { .ver = 1, .userID = 1, .bundleName = "com.ohos.access_token", .instIndex = 1, - .tokenID = 0x20100000, + .tokenID = g_testTokenId, .tokenAttr = 0 }; -void NativeTokenGet() -{ - uint32_t tokenId = AccessTokenKit::GetNativeTokenId("token_sync_service"); - ASSERT_NE(tokenId, INVALID_TOKENID); - EXPECT_EQ(0, SetSelfTokenID(tokenId)); -} - #ifdef TOKEN_SYNC_ENABLE static const int32_t FAKE_SYNC_RET = 0xabcdef; class TokenSyncCallbackImpl : public TokenSyncKitInterface { @@ -78,30 +72,36 @@ public: void RegisterTokenSyncCallbackTest::SetUpTestCase() { g_selfTokenId = GetSelfTokenID(); - - NativeTokenGet(); + TestCommon::SetTestEvironment(g_selfTokenId); #ifdef TOKEN_SYNC_ENABLE - std::shared_ptr ptrDmInitCallback = std::make_shared(); - int32_t res = DistributedHardware::DeviceManager::GetInstance().InitDeviceManager(TEST_PKG_NAME, ptrDmInitCallback); - ASSERT_EQ(res, RET_SUCCESS); + { + MockNativeToken mock("foundation"); + std::shared_ptr ptrDmInitCallback = std::make_shared(); + int32_t res = + DistributedHardware::DeviceManager::GetInstance().InitDeviceManager(TEST_PKG_NAME, ptrDmInitCallback); + ASSERT_EQ(res, RET_SUCCESS); + } #endif } void RegisterTokenSyncCallbackTest::TearDownTestCase() { - SetSelfTokenID(g_selfTokenId); #ifdef TOKEN_SYNC_ENABLE - int32_t res = DistributedHardware::DeviceManager::GetInstance().UnInitDeviceManager(TEST_PKG_NAME); - ASSERT_EQ(res, RET_SUCCESS); + { + MockNativeToken mock("foundation"); + int32_t res = DistributedHardware::DeviceManager::GetInstance().UnInitDeviceManager(TEST_PKG_NAME); + ASSERT_EQ(res, RET_SUCCESS); + } #endif + EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId)); + TestCommon::ResetTestEvironment(); } void RegisterTokenSyncCallbackTest::SetUp() { - selfTokenId_ = GetSelfTokenID(); - #ifdef TOKEN_SYNC_ENABLE + MockNativeToken mock("foundation"); DistributedHardware::DmDeviceInfo deviceInfo; int32_t res = DistributedHardware::DeviceManager::GetInstance().GetLocalDeviceInfo(TEST_PKG_NAME, deviceInfo); ASSERT_EQ(res, RET_SUCCESS); @@ -115,12 +115,11 @@ void RegisterTokenSyncCallbackTest::SetUp() #endif LOGI(ATM_DOMAIN, ATM_TAG, "SetUp ok."); - setuid(0); } void RegisterTokenSyncCallbackTest::TearDown() { - EXPECT_EQ(0, SetSelfTokenID(selfTokenId_)); + EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId)); udid_.clear(); networkId_.clear(); } @@ -148,7 +147,6 @@ HWTEST_F(RegisterTokenSyncCallbackTest, RegisterTokenSyncCallbackAbnormalTest001 HWTEST_F(RegisterTokenSyncCallbackTest, RegisterTokenSyncCallbackAbnormalTest002, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "RegisterTokenSyncCallbackAbnormalTest002 start."); - EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId)); std::shared_ptr callback = std::make_shared(); EXPECT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, AccessTokenKit::RegisterTokenSyncCallback(callback)); EXPECT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, AccessTokenKit::UnRegisterTokenSyncCallback()); @@ -162,6 +160,7 @@ HWTEST_F(RegisterTokenSyncCallbackTest, RegisterTokenSyncCallbackAbnormalTest002 */ HWTEST_F(RegisterTokenSyncCallbackTest, RegisterTokenSyncCallbackFuncTest001, TestSize.Level1) { + MockNativeToken mock("token_sync_service"); LOGI(ATM_DOMAIN, ATM_TAG, "RegisterTokenSyncCallbackFuncTest001 start."); std::shared_ptr callback = std::make_shared(); EXPECT_EQ(RET_SUCCESS, AccessTokenKit::RegisterTokenSyncCallback(callback)); diff --git a/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/register_token_sync_callback_test.h b/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/register_token_sync_callback_test.h index 7c7aaf3c06d3e36e46b6a7113f87f20b67d536eb..61e1af4e3ddab2e3ecd5059e83cf2dc98c9907e8 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/register_token_sync_callback_test.h +++ b/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/register_token_sync_callback_test.h @@ -42,7 +42,6 @@ public: void SetUp(); void TearDown(); - uint64_t selfTokenId_; std::string udid_; std::string networkId_; }; diff --git a/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/set_remote_hap_token_info_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/set_remote_hap_token_info_test.cpp index eeda26c24cb6a8804fd3cf772eae1f001d61823b..a081155148ad8ec9f80a6a7d5885473a53f638aa 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/set_remote_hap_token_info_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/set_remote_hap_token_info_test.cpp @@ -21,8 +21,8 @@ #include "accesstoken_common_log.h" #include "access_token_error.h" #include "nativetoken_kit.h" -#include "token_setproc.h" #include "test_common.h" +#include "token_setproc.h" using namespace testing::ext; using namespace OHOS::Security::AccessToken; @@ -30,24 +30,18 @@ using namespace OHOS::Security::AccessToken; namespace { static const std::string TEST_BUNDLE_NAME = "ohos"; static const std::string TEST_PKG_NAME = "com.softbus.test"; -static AccessTokenID g_selfTokenId = 0; +static uint64_t g_selfTokenId = 0; +static AccessTokenID g_testTokenId = 0x20100000; HapTokenInfo g_baseInfo = { .ver = 1, .userID = 1, .bundleName = "com.ohos.access_token", .instIndex = 1, - .tokenID = 0x20100000, + .tokenID = g_testTokenId, .tokenAttr = 0 }; -void NativeTokenGet() -{ - uint32_t tokenId = AccessTokenKit::GetNativeTokenId("token_sync_service"); - ASSERT_NE(tokenId, INVALID_TOKENID); - EXPECT_EQ(0, SetSelfTokenID(tokenId)); -} - #ifdef TOKEN_SYNC_ENABLE static const int32_t FAKE_SYNC_RET = 0xabcdef; class TokenSyncCallbackImpl : public TokenSyncKitInterface { @@ -79,30 +73,36 @@ public: void SetRemoteHapTokenInfoTest::SetUpTestCase() { g_selfTokenId = GetSelfTokenID(); - - NativeTokenGet(); + TestCommon::SetTestEvironment(g_selfTokenId); #ifdef TOKEN_SYNC_ENABLE - std::shared_ptr ptrDmInitCallback = std::make_shared(); - int32_t res = DistributedHardware::DeviceManager::GetInstance().InitDeviceManager(TEST_PKG_NAME, ptrDmInitCallback); - ASSERT_EQ(res, RET_SUCCESS); + { + MockNativeToken mock("foundation"); + std::shared_ptr ptrDmInitCallback = std::make_shared(); + int32_t res = + DistributedHardware::DeviceManager::GetInstance().InitDeviceManager(TEST_PKG_NAME, ptrDmInitCallback); + ASSERT_EQ(res, RET_SUCCESS); + } #endif } void SetRemoteHapTokenInfoTest::TearDownTestCase() { - SetSelfTokenID(g_selfTokenId); #ifdef TOKEN_SYNC_ENABLE - int32_t res = DistributedHardware::DeviceManager::GetInstance().UnInitDeviceManager(TEST_PKG_NAME); - ASSERT_EQ(res, RET_SUCCESS); + { + MockNativeToken mock("foundation"); + int32_t res = DistributedHardware::DeviceManager::GetInstance().UnInitDeviceManager(TEST_PKG_NAME); + ASSERT_EQ(res, RET_SUCCESS); + } #endif + EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId)); + TestCommon::ResetTestEvironment(); } void SetRemoteHapTokenInfoTest::SetUp() { - selfTokenId_ = GetSelfTokenID(); - #ifdef TOKEN_SYNC_ENABLE + MockNativeToken mock("foundation"); // distribute permission DistributedHardware::DmDeviceInfo deviceInfo; int32_t res = DistributedHardware::DeviceManager::GetInstance().GetLocalDeviceInfo(TEST_PKG_NAME, deviceInfo); ASSERT_EQ(res, RET_SUCCESS); @@ -116,12 +116,11 @@ void SetRemoteHapTokenInfoTest::SetUp() #endif LOGI(ATM_DOMAIN, ATM_TAG, "SetUp ok."); - setuid(0); } void SetRemoteHapTokenInfoTest::TearDown() { - EXPECT_EQ(0, SetSelfTokenID(selfTokenId_)); + EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId)); udid_.clear(); networkId_.clear(); } @@ -135,9 +134,10 @@ void SetRemoteHapTokenInfoTest::TearDown() */ HWTEST_F(SetRemoteHapTokenInfoTest, SetRemoteHapTokenInfoFuncTest001, TestSize.Level1) { + MockNativeToken mock("token_sync_service"); LOGI(ATM_DOMAIN, ATM_TAG, "SetRemoteHapTokenInfoFuncTest001 start."); std::string deviceID1 = udid_; - AccessTokenKit::DeleteRemoteToken(deviceID1, 0x20100000); + AccessTokenKit::DeleteRemoteToken(deviceID1, g_testTokenId); PermissionStatus infoManagerTestState2 = { .permissionName = "ohos.permission.CAMERA", .grantStatus = PermissionState::PERMISSION_GRANTED, @@ -154,7 +154,7 @@ HWTEST_F(SetRemoteHapTokenInfoTest, SetRemoteHapTokenInfoFuncTest001, TestSize.L ASSERT_EQ(ret, RET_SUCCESS); // Get local map token ID - AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000); + AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, g_testTokenId); ASSERT_NE(mapID, 0); // check local map token @@ -171,7 +171,7 @@ HWTEST_F(SetRemoteHapTokenInfoTest, SetRemoteHapTokenInfoFuncTest001, TestSize.L ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.CAMERA", false); ASSERT_EQ(ret, PermissionState::PERMISSION_GRANTED); - ret = AccessTokenKit::DeleteRemoteToken(deviceID1, 0x20100000); + ret = AccessTokenKit::DeleteRemoteToken(deviceID1, g_testTokenId); ASSERT_EQ(ret, RET_SUCCESS); } @@ -201,15 +201,16 @@ void SetRemoteHapTokenInfoWithWrongInfo1(HapTokenInfo &wrongBaseInfo, const HapT */ HWTEST_F(SetRemoteHapTokenInfoTest, SetRemoteHapTokenInfoFuncTest002, TestSize.Level1) { + MockNativeToken mock("token_sync_service"); LOGI(ATM_DOMAIN, ATM_TAG, "SetRemoteHapTokenInfoFuncTest002 start."); std::string deviceID2 = udid_; - AccessTokenKit::DeleteRemoteToken(deviceID2, 0x20100000); + AccessTokenKit::DeleteRemoteToken(deviceID2, g_testTokenId); HapTokenInfo rightBaseInfo = { .ver = 1, .userID = 1, .bundleName = "com.ohos.access_token", .instIndex = 1, - .tokenID = 0x20100000, + .tokenID = g_testTokenId, .tokenAttr = 0 }; @@ -242,9 +243,10 @@ HWTEST_F(SetRemoteHapTokenInfoTest, SetRemoteHapTokenInfoFuncTest002, TestSize.L */ HWTEST_F(SetRemoteHapTokenInfoTest, SetRemoteHapTokenInfoFuncTest003, TestSize.Level1) { + MockNativeToken mock("token_sync_service"); LOGI(ATM_DOMAIN, ATM_TAG, "SetRemoteHapTokenInfoFuncTest003 start."); std::string deviceID3 = udid_; - AccessTokenKit::DeleteRemoteToken(deviceID3, 0x20100000); + AccessTokenKit::DeleteRemoteToken(deviceID3, g_testTokenId); PermissionStatus infoManagerTestState_3 = { .permissionName = "ohos.permission.test1", @@ -263,13 +265,13 @@ HWTEST_F(SetRemoteHapTokenInfoTest, SetRemoteHapTokenInfoFuncTest003, TestSize.L ASSERT_EQ(ret, RET_SUCCESS); // Get local map token ID - AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000); + AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, g_testTokenId); ASSERT_NE(mapID, 0); ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.test1", false); ASSERT_EQ(ret, PermissionState::PERMISSION_DENIED); - ret = AccessTokenKit::DeleteRemoteToken(deviceID3, 0x20100000); + ret = AccessTokenKit::DeleteRemoteToken(deviceID3, g_testTokenId); ASSERT_EQ(ret, RET_SUCCESS); } @@ -281,9 +283,10 @@ HWTEST_F(SetRemoteHapTokenInfoTest, SetRemoteHapTokenInfoFuncTest003, TestSize.L */ HWTEST_F(SetRemoteHapTokenInfoTest, SetRemoteHapTokenInfoFuncTest004, TestSize.Level1) { + MockNativeToken mock("token_sync_service"); LOGI(ATM_DOMAIN, ATM_TAG, "SetRemoteHapTokenInfoFuncTest004 start."); std::string deviceID4 = udid_; - AccessTokenKit::DeleteRemoteToken(deviceID4, 0x20100000); + AccessTokenKit::DeleteRemoteToken(deviceID4, g_testTokenId); PermissionStatus infoManagerTestState_4 = { .permissionName = "ohos.permission.CAMERA", .grantStatus = PermissionState::PERMISSION_DENIED, // first denied @@ -300,7 +303,7 @@ HWTEST_F(SetRemoteHapTokenInfoTest, SetRemoteHapTokenInfoFuncTest004, TestSize.L ASSERT_EQ(ret, RET_SUCCESS); // Get local map token ID - AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000); + AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, g_testTokenId); ASSERT_NE(mapID, 0); ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.CAMERA", false); @@ -313,7 +316,7 @@ HWTEST_F(SetRemoteHapTokenInfoTest, SetRemoteHapTokenInfoFuncTest004, TestSize.L ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.CAMERA", false); ASSERT_EQ(ret, PermissionState::PERMISSION_GRANTED); - ret = AccessTokenKit::DeleteRemoteToken(deviceID4, 0x20100000); + ret = AccessTokenKit::DeleteRemoteToken(deviceID4, g_testTokenId); ASSERT_EQ(ret, RET_SUCCESS); } @@ -325,9 +328,10 @@ HWTEST_F(SetRemoteHapTokenInfoTest, SetRemoteHapTokenInfoFuncTest004, TestSize.L */ HWTEST_F(SetRemoteHapTokenInfoTest, SetRemoteHapTokenInfoSpecTest001, TestSize.Level1) { + MockNativeToken mock("token_sync_service"); LOGI(ATM_DOMAIN, ATM_TAG, "SetRemoteHapTokenInfoSpecTest001 start."); std::string deviceID5 = udid_; - AccessTokenKit::DeleteRemoteToken(deviceID5, 0x20100000); + AccessTokenKit::DeleteRemoteToken(deviceID5, g_testTokenId); PermissionStatus infoManagerTestState5 = { .permissionName = "ohos.permission.test1", .grantStatus = PermissionState::PERMISSION_DENIED, // first denied @@ -344,19 +348,24 @@ HWTEST_F(SetRemoteHapTokenInfoTest, SetRemoteHapTokenInfoSpecTest001, TestSize.L ASSERT_EQ(ret, RET_SUCCESS); // Get local map token ID - AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000); + AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, g_testTokenId); ASSERT_NE(mapID, 0); ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.test1", false); ASSERT_EQ(ret, PermissionState::PERMISSION_DENIED); - ret = AccessTokenKit::GrantPermission(mapID, "ohos.permission.test1", PermissionFlag::PERMISSION_SYSTEM_FIXED); - ASSERT_EQ(ret, ERR_PERMISSION_NOT_EXIST); + { + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.GRANT_SENSITIVE_PERMISSIONS"); + MockHapToken mock("SetRemoteHapTokenInfoSpecTest001", reqPerm); + ret = AccessTokenKit::GrantPermission(mapID, "ohos.permission.test1", PermissionFlag::PERMISSION_SYSTEM_FIXED); + ASSERT_EQ(ret, ERR_PERMISSION_NOT_EXIST); + } ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.test1", false); ASSERT_EQ(ret, PermissionState::PERMISSION_DENIED); - ret = AccessTokenKit::DeleteRemoteToken(deviceID5, 0x20100000); + ret = AccessTokenKit::DeleteRemoteToken(deviceID5, g_testTokenId); ASSERT_EQ(ret, RET_SUCCESS); } @@ -368,9 +377,10 @@ HWTEST_F(SetRemoteHapTokenInfoTest, SetRemoteHapTokenInfoSpecTest001, TestSize.L */ HWTEST_F(SetRemoteHapTokenInfoTest, SetRemoteHapTokenInfoSpecTest002, TestSize.Level1) { + MockNativeToken mock("token_sync_service"); LOGI(ATM_DOMAIN, ATM_TAG, "SetRemoteHapTokenInfoSpecTest002 start."); std::string deviceID6 = udid_; - AccessTokenKit::DeleteRemoteToken(deviceID6, 0x20100000); + AccessTokenKit::DeleteRemoteToken(deviceID6, g_testTokenId); PermissionStatus infoManagerTestState6 = { .permissionName = "ohos.permission.READ_AUDIO", .grantStatus = PermissionState::PERMISSION_GRANTED, // first grant @@ -392,20 +402,24 @@ HWTEST_F(SetRemoteHapTokenInfoTest, SetRemoteHapTokenInfoSpecTest002, TestSize.L ASSERT_EQ(ret, RET_SUCCESS); // Get local map token ID - AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000); + AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, g_testTokenId); ASSERT_NE(mapID, 0); ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.READ_AUDIO", false); EXPECT_EQ(ret, PermissionState::PERMISSION_GRANTED); - ret = AccessTokenKit::RevokePermission( - mapID, "ohos.permission.test1", PermissionFlag::PERMISSION_SYSTEM_FIXED); - EXPECT_EQ(ret, ERR_PERMISSION_NOT_EXIST); + { + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.REVOKE_SENSITIVE_PERMISSIONS"); + MockHapToken mock("SetRemoteHapTokenInfoSpecTest002", reqPerm); + ret = AccessTokenKit::RevokePermission(mapID, "ohos.permission.test1", PermissionFlag::PERMISSION_SYSTEM_FIXED); + ASSERT_EQ(ret, ERR_PERMISSION_NOT_EXIST); + } ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.READ_AUDIO", false); EXPECT_EQ(ret, PermissionState::PERMISSION_GRANTED); - ret = AccessTokenKit::DeleteRemoteToken(deviceID6, 0x20100000); + ret = AccessTokenKit::DeleteRemoteToken(deviceID6, g_testTokenId); EXPECT_EQ(ret, RET_SUCCESS); } @@ -417,9 +431,10 @@ HWTEST_F(SetRemoteHapTokenInfoTest, SetRemoteHapTokenInfoSpecTest002, TestSize.L */ HWTEST_F(SetRemoteHapTokenInfoTest, SetRemoteHapTokenInfoSpecTest003, TestSize.Level1) { + MockNativeToken mock("token_sync_service"); LOGI(ATM_DOMAIN, ATM_TAG, "SetRemoteHapTokenInfoSpecTest003 start."); std::string deviceID7 = udid_; - AccessTokenKit::DeleteRemoteToken(deviceID7, 0x20100000); + AccessTokenKit::DeleteRemoteToken(deviceID7, g_testTokenId); PermissionStatus infoManagerTestState7 = { .permissionName = "ohos.permission.READ_AUDIO", .grantStatus = PermissionState::PERMISSION_DENIED, // first denied @@ -436,13 +451,13 @@ HWTEST_F(SetRemoteHapTokenInfoTest, SetRemoteHapTokenInfoSpecTest003, TestSize.L ASSERT_EQ(ret, RET_SUCCESS); // Get local map token ID - AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000); + AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, g_testTokenId); ASSERT_NE(mapID, 0); ret = AccessTokenKit::DeleteToken(mapID); ASSERT_NE(ret, RET_SUCCESS); - ret = AccessTokenKit::DeleteRemoteToken(deviceID7, 0x20100000); + ret = AccessTokenKit::DeleteRemoteToken(deviceID7, g_testTokenId); ASSERT_EQ(ret, RET_SUCCESS); } @@ -454,9 +469,10 @@ HWTEST_F(SetRemoteHapTokenInfoTest, SetRemoteHapTokenInfoSpecTest003, TestSize.L */ HWTEST_F(SetRemoteHapTokenInfoTest, SetRemoteHapTokenInfoSpecTest004, TestSize.Level1) { + MockNativeToken mock("token_sync_service"); LOGI(ATM_DOMAIN, ATM_TAG, "SetRemoteHapTokenInfoSpecTest004 start."); std::string deviceID8 = udid_; - AccessTokenKit::DeleteRemoteToken(deviceID8, 0x20100000); + AccessTokenKit::DeleteRemoteToken(deviceID8, g_testTokenId); int32_t DEFAULT_API_VERSION = 8; PermissionStatus infoManagerTestState8 = { .permissionName = "ohos.permission.test1", @@ -474,7 +490,7 @@ HWTEST_F(SetRemoteHapTokenInfoTest, SetRemoteHapTokenInfoSpecTest004, TestSize.L ASSERT_EQ(ret, RET_SUCCESS); // Get local map token ID - AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000); + AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, g_testTokenId); ASSERT_NE(mapID, 0); AccessTokenIDEx tokenIdEx { .tokenIdExStruct.tokenID = mapID, @@ -488,7 +504,7 @@ HWTEST_F(SetRemoteHapTokenInfoTest, SetRemoteHapTokenInfoSpecTest004, TestSize.L ret = AccessTokenKit::UpdateHapToken(tokenIdEx, info, policy); ASSERT_EQ(ret, AccessTokenError::ERR_PARAM_INVALID); - ret = AccessTokenKit::DeleteRemoteToken(deviceID8, 0x20100000); + ret = AccessTokenKit::DeleteRemoteToken(deviceID8, g_testTokenId); ASSERT_EQ(ret, RET_SUCCESS); } @@ -500,9 +516,10 @@ HWTEST_F(SetRemoteHapTokenInfoTest, SetRemoteHapTokenInfoSpecTest004, TestSize.L */ HWTEST_F(SetRemoteHapTokenInfoTest, SetRemoteHapTokenInfoSpecTest005, TestSize.Level1) { + MockNativeToken mock("token_sync_service"); LOGI(ATM_DOMAIN, ATM_TAG, "SetRemoteHapTokenInfoSpecTest005 start."); std::string deviceID9 = udid_; - AccessTokenKit::DeleteRemoteToken(deviceID9, 0x20100000); + AccessTokenKit::DeleteRemoteToken(deviceID9, g_testTokenId); PermissionStatus infoManagerTestState9 = { .permissionName = "ohos.permission.CAMERA", .grantStatus = PermissionState::PERMISSION_GRANTED, @@ -519,19 +536,21 @@ HWTEST_F(SetRemoteHapTokenInfoTest, SetRemoteHapTokenInfoSpecTest005, TestSize.L ASSERT_EQ(ret, RET_SUCCESS); // Get local map token ID - AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, 0x20100000); + AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, g_testTokenId); ASSERT_NE(mapID, 0); ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.CAMERA", false); ASSERT_EQ(ret, PermissionState::PERMISSION_GRANTED); - ret = AccessTokenKit::ClearUserGrantedPermissionState(mapID); - ASSERT_EQ(ret, RET_SUCCESS); + { + MockNativeToken mock("foundation"); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::ClearUserGrantedPermissionState(mapID)); + } ret = AccessTokenKit::VerifyAccessToken(mapID, "ohos.permission.CAMERA", false); ASSERT_EQ(ret, PermissionState::PERMISSION_GRANTED); - ret = AccessTokenKit::DeleteRemoteToken(deviceID9, 0x20100000); + ret = AccessTokenKit::DeleteRemoteToken(deviceID9, g_testTokenId); ASSERT_EQ(ret, RET_SUCCESS); } @@ -543,6 +562,7 @@ HWTEST_F(SetRemoteHapTokenInfoTest, SetRemoteHapTokenInfoSpecTest005, TestSize.L */ HWTEST_F(SetRemoteHapTokenInfoTest, SetRemoteHapTokenInfoSpecTest006, TestSize.Level1) { + MockNativeToken mock("token_sync_service"); LOGI(ATM_DOMAIN, ATM_TAG, "SetRemoteHapTokenInfoSpecTest006 start."); std::string deviceID = udid_; HapTokenInfo baseInfo = { @@ -579,7 +599,6 @@ HWTEST_F(SetRemoteHapTokenInfoTest, SetRemoteHapTokenInfoSpecTest006, TestSize.L HWTEST_F(SetRemoteHapTokenInfoTest, SetRemoteHapTokenInfoAbnormalTest001, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "SetRemoteHapTokenInfoAbnormalTest001 start."); - EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId)); std::string device = "device"; HapTokenInfoForSync hapSync; ASSERT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, AccessTokenKit::SetRemoteHapTokenInfo(device, hapSync)); diff --git a/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/set_remote_hap_token_info_test.h b/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/set_remote_hap_token_info_test.h index c7fb9fcc01adf081e3a71b521e6fea4e09ca9170..cd9a34b4cab08e99d8b47de6d8f0eafb1b1d90cb 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/set_remote_hap_token_info_test.h +++ b/interfaces/innerkits/accesstoken/test/unittest/DistributedTest/set_remote_hap_token_info_test.h @@ -42,7 +42,6 @@ public: void SetUp(); void TearDown(); - uint64_t selfTokenId_; std::string udid_; std::string networkId_; }; diff --git a/interfaces/innerkits/accesstoken/test/unittest/src/clone_app_permission_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/DlpTest/clone_app_permission_test.cpp similarity index 88% rename from interfaces/innerkits/accesstoken/test/unittest/src/clone_app_permission_test.cpp rename to interfaces/innerkits/accesstoken/test/unittest/DlpTest/clone_app_permission_test.cpp index ae8b8fcc46477feeb5e0c65991594dc4dd1503d7..edd179fd756214c262b4d14810a49e7b70dec0be 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/src/clone_app_permission_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/DlpTest/clone_app_permission_test.cpp @@ -20,6 +20,7 @@ #include "accesstoken_common_log.h" #include "access_token_error.h" #include "nativetoken_kit.h" +#include "test_common.h" #include "token_setproc.h" #include "tokenid_kit.h" @@ -32,6 +33,7 @@ static const std::string PERMISSION_FULL_CONTROL = "ohos.permission.WRITE_MEDIA" static const std::string PERMISSION_NOT_DISPLAYED = "ohos.permission.ANSWER_CALL"; static const std::string TEST_PERMISSION_GRANT = "ohos.permission.GRANT_SENSITIVE_PERMISSIONS"; static const std::string TEST_PERMISSION_REVOKE = "ohos.permission.REVOKE_SENSITIVE_PERMISSIONS"; +static uint64_t g_selfTokenId = 0; HapInfoParams g_infoParmsCommon = { .userID = 1, @@ -92,7 +94,6 @@ PermissionStateFull g_stateAll = { HapPolicyParams g_policyParams = { .apl = APL_NORMAL, .domain = "test.domain", - .permList = {}, .permStateList = {g_stateFullControl, g_stateAll} }; @@ -100,9 +101,14 @@ HapPolicyParams g_policyParams = { void CloneAppPermissionTest::TearDownTestCase() { - AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(1, "PermissionEnvironment", 0); - int32_t ret = AccessTokenKit::DeleteToken(tokenId); - EXPECT_EQ(RET_SUCCESS, ret); + EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId)); + TestCommon::ResetTestEvironment(); + + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(1, "PermissionEnvironment", 0); + AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID; + if (tokenId != INVALID_TOKENID) { + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenId)); + } } void CloneAppPermissionTest::SetUp() @@ -116,6 +122,9 @@ void CloneAppPermissionTest::TearDown() void CloneAppPermissionTest::SetUpTestCase() { + g_selfTokenId = GetSelfTokenID(); + TestCommon::SetTestEvironment(g_selfTokenId); + HapInfoParams infoParmsEnvironment = { .userID = 1, .bundleName = "PermissionEnvironment", @@ -141,11 +150,10 @@ void CloneAppPermissionTest::SetUpTestCase() HapPolicyParams policyParams = { .apl = APL_NORMAL, .domain = "test.domain", - .permList = {}, .permStateList = {stateGrant, stateRevoke} }; AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(infoParmsEnvironment, policyParams); + EXPECT_EQ(RET_SUCCESS, TestCommon::AllocTestHapToken(infoParmsEnvironment, policyParams, tokenIdEx)); EXPECT_NE(0, tokenIdEx.tokenIdExStruct.tokenID); EXPECT_EQ(true, TokenIdKit::IsSystemAppByFullTokenID(tokenIdEx.tokenIDEx)); EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); @@ -155,9 +163,9 @@ void CloneAppPermissionTest::SetUpTestCase() static AccessTokenID AllocHapTokenId(HapInfoParams info, HapPolicyParams policy) { AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(info, policy); + EXPECT_EQ(RET_SUCCESS, TestCommon::AllocTestHapToken(info, policy, tokenIdEx)); AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID; - EXPECT_NE(0, tokenId); + EXPECT_NE(INVALID_TOKENID, tokenId); int ret = AccessTokenKit::VerifyAccessToken(tokenId, PERMISSION_FULL_CONTROL, false); EXPECT_EQ(ret, PermissionState::PERMISSION_DENIED); ret = AccessTokenKit::VerifyAccessToken(tokenId, PERMISSION_ALL, false); @@ -202,15 +210,15 @@ HWTEST_F(CloneAppPermissionTest, OriginApp01, TestSize.Level1) ret = AccessTokenKit::VerifyAccessToken(tokenClone2, PERMISSION_ALL); EXPECT_EQ(ret, PermissionState::PERMISSION_DENIED); - ret = AccessTokenKit::DeleteToken(tokenCommon); + ret = TestCommon::DeleteTestHapToken(tokenCommon); EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenFullControl); + ret = TestCommon::DeleteTestHapToken(tokenFullControl); EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenRead); + ret = TestCommon::DeleteTestHapToken(tokenRead); EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenClone1); + ret = TestCommon::DeleteTestHapToken(tokenClone1); EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenClone2); + ret = TestCommon::DeleteTestHapToken(tokenClone2); EXPECT_EQ(RET_SUCCESS, ret); } @@ -264,15 +272,15 @@ HWTEST_F(CloneAppPermissionTest, OriginApp02, TestSize.Level1) EXPECT_EQ(flag, 0); EXPECT_EQ(ret, RET_SUCCESS); - ret = AccessTokenKit::DeleteToken(tokenCommon); + ret = TestCommon::DeleteTestHapToken(tokenCommon); EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenFullControl); + ret = TestCommon::DeleteTestHapToken(tokenFullControl); EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenRead); + ret = TestCommon::DeleteTestHapToken(tokenRead); EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenClone1); + ret = TestCommon::DeleteTestHapToken(tokenClone1); EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenClone2); + ret = TestCommon::DeleteTestHapToken(tokenClone2); EXPECT_EQ(RET_SUCCESS, ret); } @@ -337,11 +345,11 @@ HWTEST_F(CloneAppPermissionTest, OriginApp03, TestSize.Level1) EXPECT_EQ(flag, PERMISSION_USER_FIXED); EXPECT_EQ(ret, RET_SUCCESS); - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenCommon)); - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenFullControl)); - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenRead)); - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenClone1)); - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenClone2)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenCommon)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenFullControl)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenRead)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenClone1)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenClone2)); } /** @@ -374,15 +382,15 @@ HWTEST_F(CloneAppPermissionTest, ReadDlp01, TestSize.Level1) ret = AccessTokenKit::VerifyAccessToken(tokenClone2, PERMISSION_ALL); EXPECT_EQ(ret, PermissionState::PERMISSION_DENIED); - ret = AccessTokenKit::DeleteToken(tokenCommon); + ret = TestCommon::DeleteTestHapToken(tokenCommon); EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenFullControl); + ret = TestCommon::DeleteTestHapToken(tokenFullControl); EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenRead); + ret = TestCommon::DeleteTestHapToken(tokenRead); EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenClone1); + ret = TestCommon::DeleteTestHapToken(tokenClone1); EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenClone2); + ret = TestCommon::DeleteTestHapToken(tokenClone2); EXPECT_EQ(RET_SUCCESS, ret); } @@ -437,15 +445,15 @@ HWTEST_F(CloneAppPermissionTest, ReadDlp02, TestSize.Level1) EXPECT_EQ(flag, 0); EXPECT_EQ(ret, RET_SUCCESS); - ret = AccessTokenKit::DeleteToken(tokenCommon); + ret = TestCommon::DeleteTestHapToken(tokenCommon); EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenFullControl); + ret = TestCommon::DeleteTestHapToken(tokenFullControl); EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenRead); + ret = TestCommon::DeleteTestHapToken(tokenRead); EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenClone1); + ret = TestCommon::DeleteTestHapToken(tokenClone1); EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenClone2); + ret = TestCommon::DeleteTestHapToken(tokenClone2); EXPECT_EQ(RET_SUCCESS, ret); } @@ -508,11 +516,11 @@ HWTEST_F(CloneAppPermissionTest, ReadDlp03, TestSize.Level1) EXPECT_EQ(flag, PERMISSION_USER_FIXED); EXPECT_EQ(ret, RET_SUCCESS); - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenCommon)); - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenFullControl)); - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenRead)); - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenClone1)); - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenClone2)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenCommon)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenFullControl)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenRead)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenClone1)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenClone2)); } @@ -546,15 +554,15 @@ HWTEST_F(CloneAppPermissionTest, CloneApp01, TestSize.Level1) ret = AccessTokenKit::VerifyAccessToken(tokenClone2, PERMISSION_ALL); EXPECT_EQ(ret, PermissionState::PERMISSION_DENIED); - ret = AccessTokenKit::DeleteToken(tokenCommon); + ret = TestCommon::DeleteTestHapToken(tokenCommon); EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenFullControl); + ret = TestCommon::DeleteTestHapToken(tokenFullControl); EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenRead); + ret = TestCommon::DeleteTestHapToken(tokenRead); EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenClone1); + ret = TestCommon::DeleteTestHapToken(tokenClone1); EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenClone2); + ret = TestCommon::DeleteTestHapToken(tokenClone2); EXPECT_EQ(RET_SUCCESS, ret); } @@ -598,15 +606,15 @@ HWTEST_F(CloneAppPermissionTest, CloneApp02, TestSize.Level1) EXPECT_EQ(flag, 0); EXPECT_EQ(ret, RET_SUCCESS); - ret = AccessTokenKit::DeleteToken(tokenCommon); + ret = TestCommon::DeleteTestHapToken(tokenCommon); EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenFullControl); + ret = TestCommon::DeleteTestHapToken(tokenFullControl); EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenRead); + ret = TestCommon::DeleteTestHapToken(tokenRead); EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenClone1); + ret = TestCommon::DeleteTestHapToken(tokenClone1); EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenClone2); + ret = TestCommon::DeleteTestHapToken(tokenClone2); EXPECT_EQ(RET_SUCCESS, ret); } @@ -669,11 +677,11 @@ HWTEST_F(CloneAppPermissionTest, CloneApp03, TestSize.Level1) EXPECT_EQ(flag, PERMISSION_USER_FIXED); EXPECT_EQ(ret, RET_SUCCESS); - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenCommon)); - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenFullControl)); - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenRead)); - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenClone1)); - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenClone2)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenCommon)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenFullControl)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenRead)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenClone1)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenClone2)); } @@ -719,11 +727,11 @@ HWTEST_F(CloneAppPermissionTest, CloneApp04, TestSize.Level1) EXPECT_EQ(flag, 0); EXPECT_EQ(ret, RET_SUCCESS); - ret = AccessTokenKit::DeleteToken(tokenCommon); + ret = TestCommon::DeleteTestHapToken(tokenCommon); EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenClone1); + ret = TestCommon::DeleteTestHapToken(tokenClone1); EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenClone2); + ret = TestCommon::DeleteTestHapToken(tokenClone2); EXPECT_EQ(RET_SUCCESS, ret); } @@ -776,14 +784,14 @@ HWTEST_F(CloneAppPermissionTest, CloneApp05, TestSize.Level1) dlpFlag = static_cast(idInner->dlpFlag); EXPECT_EQ(dlpFlag, 0); - ret = AccessTokenKit::DeleteToken(tokenCommon); + ret = TestCommon::DeleteTestHapToken(tokenCommon); EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenFullControl); + ret = TestCommon::DeleteTestHapToken(tokenFullControl); EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenRead); + ret = TestCommon::DeleteTestHapToken(tokenRead); EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenClone1); + ret = TestCommon::DeleteTestHapToken(tokenClone1); EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenClone2); + ret = TestCommon::DeleteTestHapToken(tokenClone2); EXPECT_EQ(RET_SUCCESS, ret); } \ No newline at end of file diff --git a/interfaces/innerkits/accesstoken/test/unittest/src/clone_app_permission_test.h b/interfaces/innerkits/accesstoken/test/unittest/DlpTest/clone_app_permission_test.h similarity index 96% rename from interfaces/innerkits/accesstoken/test/unittest/src/clone_app_permission_test.h rename to interfaces/innerkits/accesstoken/test/unittest/DlpTest/clone_app_permission_test.h index f0543534fff3e7359b5f1c0d6505ce6f04ba4e07..473bca7db249096140184426bb3eb33aafea3c61 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/src/clone_app_permission_test.h +++ b/interfaces/innerkits/accesstoken/test/unittest/DlpTest/clone_app_permission_test.h @@ -27,7 +27,6 @@ public: static void TearDownTestCase(); void TearDown(); void SetUp(); - static uint64_t selfTokenId_; }; } // namespace AccessToken } // namespace Security diff --git a/interfaces/innerkits/accesstoken/test/unittest/src/share_permission_with_sandbox_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/DlpTest/share_permission_with_sandbox_test.cpp similarity index 77% rename from interfaces/innerkits/accesstoken/test/unittest/src/share_permission_with_sandbox_test.cpp rename to interfaces/innerkits/accesstoken/test/unittest/DlpTest/share_permission_with_sandbox_test.cpp index ee27ccaeb4e69390c2d15bfd8d5acffb3cd4c561..df352af24655fa44e7a35f7ac68480f2b2049bd5 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/src/share_permission_with_sandbox_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/DlpTest/share_permission_with_sandbox_test.cpp @@ -20,6 +20,7 @@ #include "accesstoken_common_log.h" #include "access_token_error.h" #include "nativetoken_kit.h" +#include "test_common.h" #include "token_setproc.h" #include "tokenid_kit.h" @@ -33,6 +34,7 @@ static const std::string PERMISSION_NONE = "ohos.permission.INTERNET"; static const std::string PERMISSION_NOT_DISPLAYED = "ohos.permission.ANSWER_CALL"; static const std::string TEST_PERMISSION_GRANT = "ohos.permission.GRANT_SENSITIVE_PERMISSIONS"; static const std::string TEST_PERMISSION_REVOKE = "ohos.permission.REVOKE_SENSITIVE_PERMISSIONS"; +static uint64_t g_selfTokenId = 0; HapInfoParams g_infoParmsCommon = { .userID = 1, @@ -93,7 +95,6 @@ PermissionStateFull g_stateNotDisplayed = { HapPolicyParams g_policyParams = { .apl = APL_NORMAL, .domain = "test.domain", - .permList = {}, .permStateList = {g_stateFullControl, g_stateNone, g_stateAll, g_stateNotDisplayed} }; @@ -101,6 +102,9 @@ HapPolicyParams g_policyParams = { void SharePermissionTest::SetUpTestCase() { + g_selfTokenId = GetSelfTokenID(); + TestCommon::SetTestEvironment(g_selfTokenId); + HapInfoParams infoParmsEnvironment = { .userID = 1, .bundleName = "PermissionEnvironment", @@ -126,11 +130,10 @@ void SharePermissionTest::SetUpTestCase() HapPolicyParams policyParams = { .apl = APL_NORMAL, .domain = "test.domain", - .permList = {}, .permStateList = {stateGrant, stateRevoke} }; AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(infoParmsEnvironment, policyParams); + EXPECT_EQ(RET_SUCCESS, TestCommon::AllocTestHapToken(infoParmsEnvironment, policyParams, tokenIdEx)); EXPECT_NE(0, tokenIdEx.tokenIdExStruct.tokenID); EXPECT_EQ(true, TokenIdKit::IsSystemAppByFullTokenID(tokenIdEx.tokenIDEx)); EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); @@ -139,9 +142,14 @@ void SharePermissionTest::SetUpTestCase() void SharePermissionTest::TearDownTestCase() { - AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(1, "PermissionEnvironment", 0); - int32_t ret = AccessTokenKit::DeleteToken(tokenId); - EXPECT_EQ(RET_SUCCESS, ret); + EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId)); + TestCommon::ResetTestEvironment(); + + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(1, "PermissionEnvironment", 0); + AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID; + if (tokenId != INVALID_TOKENID) { + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenId)); + } } void SharePermissionTest::SetUp() @@ -155,8 +163,8 @@ void SharePermissionTest::TearDown() static AccessTokenID AllocHapTokenId(HapInfoParams info, HapPolicyParams policy) { - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(info, policy); + MockNativeToken mock("foundation"); + AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(info, policy); AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID; EXPECT_NE(0, tokenId); int ret = AccessTokenKit::VerifyAccessToken(tokenId, PERMISSION_FULL_CONTROL, false); @@ -182,7 +190,7 @@ HWTEST_F(SharePermissionTest, PermissionShareTest001, TestSize.Level1) AccessTokenID tokenFullRead = AllocHapTokenId(g_infoParmsReadOnly, g_policyParams); // grant common app - ret = AccessTokenKit::GrantPermission(tokenCommon, PERMISSION_ALL, PERMISSION_USER_FIXED); + ret = TestCommon::GrantPermissionByTest(tokenCommon, PERMISSION_ALL, PERMISSION_USER_FIXED); EXPECT_EQ(RET_SUCCESS, ret); ret = AccessTokenKit::VerifyAccessToken(tokenCommon, PERMISSION_ALL, false); EXPECT_EQ(ret, PermissionState::PERMISSION_GRANTED); @@ -192,7 +200,7 @@ HWTEST_F(SharePermissionTest, PermissionShareTest001, TestSize.Level1) EXPECT_EQ(ret, PermissionState::PERMISSION_GRANTED); // grant common app - ret = AccessTokenKit::GrantPermission(tokenCommon, PERMISSION_FULL_CONTROL, PERMISSION_USER_FIXED); + ret = TestCommon::GrantPermissionByTest(tokenCommon, PERMISSION_FULL_CONTROL, PERMISSION_USER_FIXED); EXPECT_EQ(RET_SUCCESS, ret); ret = AccessTokenKit::VerifyAccessToken(tokenCommon, PERMISSION_FULL_CONTROL, false); EXPECT_EQ(ret, PermissionState::PERMISSION_GRANTED); @@ -202,7 +210,7 @@ HWTEST_F(SharePermissionTest, PermissionShareTest001, TestSize.Level1) EXPECT_EQ(ret, PermissionState::PERMISSION_DENIED); // grant common app - ret = AccessTokenKit::GrantPermission(tokenCommon, PERMISSION_NONE, PERMISSION_USER_FIXED); + ret = TestCommon::GrantPermissionByTest(tokenCommon, PERMISSION_NONE, PERMISSION_USER_FIXED); EXPECT_EQ(RET_SUCCESS, ret); ret = AccessTokenKit::VerifyAccessToken(tokenCommon, PERMISSION_NONE, false); EXPECT_EQ(ret, PermissionState::PERMISSION_GRANTED); @@ -211,12 +219,9 @@ HWTEST_F(SharePermissionTest, PermissionShareTest001, TestSize.Level1) ret = AccessTokenKit::VerifyAccessToken(tokenFullRead, PERMISSION_NONE, false); EXPECT_EQ(ret, PermissionState::PERMISSION_DENIED); - ret = AccessTokenKit::DeleteToken(tokenCommon); - EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenFullControl); - EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenFullRead); - EXPECT_EQ(RET_SUCCESS, ret); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenCommon)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenFullControl)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenFullRead)); } /** @@ -233,7 +238,7 @@ HWTEST_F(SharePermissionTest, PermissionShareTest002, TestSize.Level1) AccessTokenID tokenFullRead = AllocHapTokenId(g_infoParmsReadOnly, g_policyParams); // grant common app - ret = AccessTokenKit::GrantPermission(tokenFullControl, PERMISSION_ALL, PERMISSION_USER_FIXED); + ret = TestCommon::GrantPermissionByTest(tokenFullControl, PERMISSION_ALL, PERMISSION_USER_FIXED); EXPECT_EQ(RET_SUCCESS, ret); ret = AccessTokenKit::VerifyAccessToken(tokenCommon, PERMISSION_ALL, false); EXPECT_EQ(ret, PermissionState::PERMISSION_GRANTED); @@ -243,7 +248,7 @@ HWTEST_F(SharePermissionTest, PermissionShareTest002, TestSize.Level1) EXPECT_EQ(ret, PermissionState::PERMISSION_GRANTED); // grant common app - ret = AccessTokenKit::GrantPermission(tokenFullControl, PERMISSION_FULL_CONTROL, PERMISSION_USER_FIXED); + ret = TestCommon::GrantPermissionByTest(tokenFullControl, PERMISSION_FULL_CONTROL, PERMISSION_USER_FIXED); EXPECT_EQ(RET_SUCCESS, ret); ret = AccessTokenKit::VerifyAccessToken(tokenCommon, PERMISSION_FULL_CONTROL, false); EXPECT_EQ(ret, PermissionState::PERMISSION_GRANTED); @@ -253,7 +258,7 @@ HWTEST_F(SharePermissionTest, PermissionShareTest002, TestSize.Level1) EXPECT_EQ(ret, PermissionState::PERMISSION_DENIED); // grant common app - ret = AccessTokenKit::GrantPermission(tokenFullControl, PERMISSION_NONE, PERMISSION_USER_FIXED); + ret = TestCommon::GrantPermissionByTest(tokenFullControl, PERMISSION_NONE, PERMISSION_USER_FIXED); EXPECT_NE(RET_SUCCESS, ret); ret = AccessTokenKit::VerifyAccessToken(tokenCommon, PERMISSION_NONE, false); EXPECT_EQ(ret, PermissionState::PERMISSION_DENIED); @@ -262,12 +267,9 @@ HWTEST_F(SharePermissionTest, PermissionShareTest002, TestSize.Level1) ret = AccessTokenKit::VerifyAccessToken(tokenFullRead, PERMISSION_NONE, false); EXPECT_EQ(ret, PermissionState::PERMISSION_DENIED); - ret = AccessTokenKit::DeleteToken(tokenCommon); - EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenFullControl); - EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenFullRead); - EXPECT_EQ(RET_SUCCESS, ret); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenCommon)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenFullControl)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenFullRead)); } /** @@ -284,14 +286,14 @@ HWTEST_F(SharePermissionTest, PermissionShareClearUserGrantTest001, TestSize.Lev AccessTokenID tokenFullRead = AllocHapTokenId(g_infoParmsReadOnly, g_policyParams); // grant pre-authorization - ret = AccessTokenKit::GrantPermission(tokenFullControl, PERMISSION_ALL, PERMISSION_GRANTED_BY_POLICY); + ret = TestCommon::GrantPermissionByTest(tokenFullControl, PERMISSION_ALL, PERMISSION_GRANTED_BY_POLICY); EXPECT_EQ(RET_SUCCESS, ret); uint32_t flag; - (void)AccessTokenKit::GetPermissionFlag(tokenCommon, PERMISSION_ALL, flag); + EXPECT_EQ(RET_SUCCESS, TestCommon::GetPermissionFlagByTest(tokenCommon, PERMISSION_ALL, flag)); EXPECT_EQ(flag, PERMISSION_DEFAULT_FLAG); - (void)AccessTokenKit::GetPermissionFlag(tokenFullControl, PERMISSION_ALL, flag); + EXPECT_EQ(RET_SUCCESS, TestCommon::GetPermissionFlagByTest(tokenFullControl, PERMISSION_ALL, flag)); EXPECT_EQ(flag, PERMISSION_DEFAULT_FLAG); - (void)AccessTokenKit::GetPermissionFlag(tokenFullRead, PERMISSION_ALL, flag); + EXPECT_EQ(RET_SUCCESS, TestCommon::GetPermissionFlagByTest(tokenFullRead, PERMISSION_ALL, flag)); EXPECT_EQ(flag, PERMISSION_DEFAULT_FLAG); ret = AccessTokenKit::RevokePermission(tokenFullControl, PERMISSION_ALL, PERMISSION_USER_FIXED); @@ -306,12 +308,9 @@ HWTEST_F(SharePermissionTest, PermissionShareClearUserGrantTest001, TestSize.Lev ret = AccessTokenKit::VerifyAccessToken(tokenFullRead, PERMISSION_ALL, false); EXPECT_EQ(ret, PermissionState::PERMISSION_GRANTED); - ret = AccessTokenKit::DeleteToken(tokenFullControl); - EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenFullRead); - EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenCommon); - EXPECT_EQ(RET_SUCCESS, ret); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenCommon)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenFullControl)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenFullRead)); } /** @@ -328,32 +327,32 @@ HWTEST_F(SharePermissionTest, PermissionShareClearUserGrantTest002, TestSize.Lev AccessTokenID tokenFullRead = AllocHapTokenId(g_infoParmsReadOnly, g_policyParams); // grant pre-authorization - ret = AccessTokenKit::GrantPermission(tokenFullControl, PERMISSION_FULL_CONTROL, PERMISSION_USER_FIXED); + ret = TestCommon::GrantPermissionByTest(tokenFullControl, PERMISSION_FULL_CONTROL, PERMISSION_USER_FIXED); EXPECT_EQ(RET_SUCCESS, ret); uint32_t flag; - (void)AccessTokenKit::GetPermissionFlag(tokenCommon, PERMISSION_FULL_CONTROL, flag); + EXPECT_EQ(RET_SUCCESS, TestCommon::GetPermissionFlagByTest(tokenCommon, PERMISSION_FULL_CONTROL, flag)); EXPECT_EQ(flag, PERMISSION_USER_FIXED); - (void)AccessTokenKit::GetPermissionFlag(tokenFullControl, PERMISSION_FULL_CONTROL, flag); + EXPECT_EQ(RET_SUCCESS, TestCommon::GetPermissionFlagByTest(tokenFullControl, PERMISSION_FULL_CONTROL, flag)); EXPECT_EQ(flag, PERMISSION_USER_FIXED); - (void)AccessTokenKit::GetPermissionFlag(tokenFullRead, PERMISSION_FULL_CONTROL, flag); + EXPECT_EQ(RET_SUCCESS, TestCommon::GetPermissionFlagByTest(tokenFullRead, PERMISSION_FULL_CONTROL, flag)); EXPECT_EQ(flag, PERMISSION_DEFAULT_FLAG); ret = AccessTokenKit::RevokePermission(tokenFullControl, PERMISSION_FULL_CONTROL, PERMISSION_USER_FIXED); EXPECT_EQ(RET_SUCCESS, ret); - (void)AccessTokenKit::GetPermissionFlag(tokenCommon, PERMISSION_FULL_CONTROL, flag); + EXPECT_EQ(RET_SUCCESS, TestCommon::GetPermissionFlagByTest(tokenCommon, PERMISSION_FULL_CONTROL, flag)); EXPECT_EQ(flag, PERMISSION_USER_FIXED); - (void)AccessTokenKit::GetPermissionFlag(tokenFullControl, PERMISSION_FULL_CONTROL, flag); + EXPECT_EQ(RET_SUCCESS, TestCommon::GetPermissionFlagByTest(tokenFullControl, PERMISSION_FULL_CONTROL, flag)); EXPECT_EQ(flag, PERMISSION_USER_FIXED); - (void)AccessTokenKit::GetPermissionFlag(tokenFullRead, PERMISSION_FULL_CONTROL, flag); + EXPECT_EQ(RET_SUCCESS, TestCommon::GetPermissionFlagByTest(tokenFullRead, PERMISSION_FULL_CONTROL, flag)); EXPECT_EQ(flag, PERMISSION_DEFAULT_FLAG); ret = AccessTokenKit::ClearUserGrantedPermissionState(tokenCommon); EXPECT_EQ(RET_SUCCESS, ret); - (void)AccessTokenKit::GetPermissionFlag(tokenCommon, PERMISSION_FULL_CONTROL, flag); + EXPECT_EQ(RET_SUCCESS, TestCommon::GetPermissionFlagByTest(tokenCommon, PERMISSION_FULL_CONTROL, flag)); EXPECT_EQ(flag, PERMISSION_DEFAULT_FLAG); - (void)AccessTokenKit::GetPermissionFlag(tokenFullControl, PERMISSION_FULL_CONTROL, flag); + EXPECT_EQ(RET_SUCCESS, TestCommon::GetPermissionFlagByTest(tokenFullControl, PERMISSION_FULL_CONTROL, flag)); EXPECT_EQ(flag, PERMISSION_DEFAULT_FLAG); - (void)AccessTokenKit::GetPermissionFlag(tokenFullRead, PERMISSION_FULL_CONTROL, flag); + EXPECT_EQ(RET_SUCCESS, TestCommon::GetPermissionFlagByTest(tokenFullRead, PERMISSION_FULL_CONTROL, flag)); EXPECT_EQ(flag, PERMISSION_DEFAULT_FLAG); ret = AccessTokenKit::VerifyAccessToken(tokenCommon, PERMISSION_FULL_CONTROL, false); EXPECT_EQ(ret, PermissionState::PERMISSION_DENIED); @@ -362,12 +361,9 @@ HWTEST_F(SharePermissionTest, PermissionShareClearUserGrantTest002, TestSize.Lev ret = AccessTokenKit::VerifyAccessToken(tokenFullRead, PERMISSION_FULL_CONTROL, false); EXPECT_EQ(ret, PermissionState::PERMISSION_DENIED); - ret = AccessTokenKit::DeleteToken(tokenFullControl); - EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenFullRead); - EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenCommon); - EXPECT_EQ(RET_SUCCESS, ret); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenCommon)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenFullControl)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenFullRead)); } /** @@ -395,7 +391,7 @@ HWTEST_F(SharePermissionTest, PermissionShareTest03, TestSize.Level1) AccessTokenKit::GetSelfPermissionsState(permsList, info); EXPECT_EQ(permsList[0].state, INVALID_OPER); - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenCommon)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenCommon)); ASSERT_EQ(0, SetSelfTokenID(tokenId)); } @@ -476,13 +472,12 @@ HWTEST_F(SharePermissionTest, PermissionShareTest004, TestSize.Level1) AccessTokenKit::GetSelfPermissionsState(permsList, info); EXPECT_EQ(permsList[2].state, INVALID_OPER); - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenCommon)); - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenFullControl)); - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenFullRead)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenCommon)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenFullControl)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenFullRead)); ASSERT_EQ(0, SetSelfTokenID(tokenId)); } - /** * @tc.name: SharePermissionTest005 * @tc.desc: . @@ -540,9 +535,9 @@ HWTEST_F(SharePermissionTest, PermissionShareTest005, TestSize.Level1) AccessTokenKit::GetSelfPermissionsState(permsList, info); EXPECT_EQ(permsList[1].state, SETTING_OPER); - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenCommon)); - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenFullControl)); - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenFullRead)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenCommon)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenFullControl)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenFullRead)); ASSERT_EQ(0, SetSelfTokenID(tokenId)); } @@ -573,26 +568,26 @@ HWTEST_F(SharePermissionTest, PermissionShareTest006, TestSize.Level1) // revoke common app ret = AccessTokenKit::RevokePermission(tokenCommon, PERMISSION_FULL_CONTROL, PERMISSION_USER_FIXED); EXPECT_EQ(RET_SUCCESS, ret); - (void)AccessTokenKit::GetPermissionFlag(tokenCommon, PERMISSION_FULL_CONTROL, flag); + EXPECT_EQ(RET_SUCCESS, TestCommon::GetPermissionFlagByTest(tokenCommon, PERMISSION_FULL_CONTROL, flag)); EXPECT_EQ(flag, PERMISSION_USER_FIXED); - (void)AccessTokenKit::GetPermissionFlag(tokenFullControl, PERMISSION_FULL_CONTROL, flag); + EXPECT_EQ(RET_SUCCESS, TestCommon::GetPermissionFlagByTest(tokenFullControl, PERMISSION_FULL_CONTROL, flag)); EXPECT_EQ(flag, PERMISSION_USER_FIXED); - (void)AccessTokenKit::GetPermissionFlag(tokenFullRead, PERMISSION_FULL_CONTROL, flag); + EXPECT_EQ(RET_SUCCESS, TestCommon::GetPermissionFlagByTest(tokenFullRead, PERMISSION_FULL_CONTROL, flag)); EXPECT_EQ(flag, PERMISSION_DEFAULT_FLAG); // revoke common app - ret = AccessTokenKit::GrantPermission(tokenCommon, PERMISSION_NONE, PERMISSION_USER_FIXED); + ret = TestCommon::GrantPermissionByTest(tokenCommon, PERMISSION_NONE, PERMISSION_USER_FIXED); EXPECT_EQ(RET_SUCCESS, ret); - (void)AccessTokenKit::GetPermissionFlag(tokenCommon, PERMISSION_NONE, flag); + EXPECT_EQ(RET_SUCCESS, TestCommon::GetPermissionFlagByTest(tokenCommon, PERMISSION_NONE, flag)); EXPECT_EQ(flag, PERMISSION_USER_FIXED); - (void)AccessTokenKit::GetPermissionFlag(tokenFullControl, PERMISSION_NONE, flag); + EXPECT_EQ(RET_SUCCESS, TestCommon::GetPermissionFlagByTest(tokenFullControl, PERMISSION_NONE, flag)); EXPECT_EQ(flag, PERMISSION_DEFAULT_FLAG); - (void)AccessTokenKit::GetPermissionFlag(tokenFullRead, PERMISSION_NONE, flag); + EXPECT_EQ(RET_SUCCESS, TestCommon::GetPermissionFlagByTest(tokenFullRead, PERMISSION_NONE, flag)); EXPECT_EQ(flag, PERMISSION_DEFAULT_FLAG); - (void)AccessTokenKit::DeleteToken(tokenCommon); - (void)AccessTokenKit::DeleteToken(tokenFullControl); - (void)AccessTokenKit::DeleteToken(tokenFullRead); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenCommon)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenFullControl)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenFullRead)); } /** @@ -612,27 +607,24 @@ HWTEST_F(SharePermissionTest, PermissionShareTest007, TestSize.Level1) // revoke full control app ret = AccessTokenKit::RevokePermission(tokenFullControl, PERMISSION_ALL, PERMISSION_USER_SET); EXPECT_EQ(RET_SUCCESS, ret); - (void)AccessTokenKit::GetPermissionFlag(tokenCommon, PERMISSION_ALL, flag); + EXPECT_EQ(RET_SUCCESS, TestCommon::GetPermissionFlagByTest(tokenCommon, PERMISSION_ALL, flag)); EXPECT_EQ(flag, PERMISSION_USER_SET); - (void)AccessTokenKit::GetPermissionFlag(tokenFullControl, PERMISSION_ALL, flag); + EXPECT_EQ(RET_SUCCESS, TestCommon::GetPermissionFlagByTest(tokenFullControl, PERMISSION_ALL, flag)); EXPECT_EQ(flag, PERMISSION_USER_SET); - (void)AccessTokenKit::GetPermissionFlag(tokenFullRead, PERMISSION_ALL, flag); + EXPECT_EQ(RET_SUCCESS, TestCommon::GetPermissionFlagByTest(tokenFullRead, PERMISSION_ALL, flag)); EXPECT_EQ(flag, PERMISSION_USER_SET); // revoke full control app - ret = AccessTokenKit::RevokePermission(tokenFullControl, PERMISSION_FULL_CONTROL, PERMISSION_USER_FIXED); + ret = TestCommon::RevokePermissionByTest(tokenFullControl, PERMISSION_FULL_CONTROL, PERMISSION_USER_FIXED); EXPECT_EQ(RET_SUCCESS, ret); - (void)AccessTokenKit::GetPermissionFlag(tokenCommon, PERMISSION_FULL_CONTROL, flag); + EXPECT_EQ(RET_SUCCESS, TestCommon::GetPermissionFlagByTest(tokenCommon, PERMISSION_FULL_CONTROL, flag)); EXPECT_EQ(flag, PERMISSION_USER_FIXED); - (void)AccessTokenKit::GetPermissionFlag(tokenFullControl, PERMISSION_FULL_CONTROL, flag); + EXPECT_EQ(RET_SUCCESS, TestCommon::GetPermissionFlagByTest(tokenFullControl, PERMISSION_FULL_CONTROL, flag)); EXPECT_EQ(flag, PERMISSION_USER_FIXED); - (void)AccessTokenKit::GetPermissionFlag(tokenFullRead, PERMISSION_FULL_CONTROL, flag); + EXPECT_EQ(RET_SUCCESS, TestCommon::GetPermissionFlagByTest(tokenFullRead, PERMISSION_FULL_CONTROL, flag)); EXPECT_EQ(flag, PERMISSION_DEFAULT_FLAG); - ret = AccessTokenKit::DeleteToken(tokenCommon); - EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenFullControl); - EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::DeleteToken(tokenFullRead); - EXPECT_EQ(RET_SUCCESS, ret); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenCommon)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenFullControl)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenFullRead)); } \ No newline at end of file diff --git a/interfaces/innerkits/accesstoken/test/unittest/src/share_permission_with_sandbox_test.h b/interfaces/innerkits/accesstoken/test/unittest/DlpTest/share_permission_with_sandbox_test.h similarity index 96% rename from interfaces/innerkits/accesstoken/test/unittest/src/share_permission_with_sandbox_test.h rename to interfaces/innerkits/accesstoken/test/unittest/DlpTest/share_permission_with_sandbox_test.h index daeba1f7616bb2a7f15148b8e19b1ea42e470116..d6f895687ea7073ca9bdca47b353f0d5e081d9a6 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/src/share_permission_with_sandbox_test.h +++ b/interfaces/innerkits/accesstoken/test/unittest/DlpTest/share_permission_with_sandbox_test.h @@ -27,7 +27,6 @@ public: static void TearDownTestCase(); void TearDown(); void SetUp(); - static uint64_t selfTokenId_; }; } // namespace AccessToken } // namespace Security diff --git a/interfaces/innerkits/accesstoken/test/unittest/src/edm_policy_set_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/EdmPolicyTest/edm_policy_set_test.cpp similarity index 76% rename from interfaces/innerkits/accesstoken/test/unittest/src/edm_policy_set_test.cpp rename to interfaces/innerkits/accesstoken/test/unittest/EdmPolicyTest/edm_policy_set_test.cpp index a644858e7a9c86e0ca67a64f6a48486cdde48399..3c9bfe92e870a66d342a3e7cec12a52129b24194 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/src/edm_policy_set_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/EdmPolicyTest/edm_policy_set_test.cpp @@ -21,6 +21,7 @@ #include "access_token_error.h" #include "permission_map.h" #include "perm_setproc.h" +#include "test_common.h" #include "token_setproc.h" #include "tokenid_kit.h" @@ -38,7 +39,6 @@ static const std::string GET_NETWORK_STATS = "ohos.permission.GET_NETWORK_STATS" static const std::string LOCATION = "ohos.permission.LOCATION"; static const std::string GET_SENSITIVE_PERMISSIONS = "ohos.permission.GET_SENSITIVE_PERMISSIONS"; static const std::string REVOKE_SENSITIVE_PERMISSIONS = "ohos.permission.REVOKE_SENSITIVE_PERMISSIONS"; - PermissionStateFull g_infoManagerInternetState = { .permissionName = INTERNET, .isGeneral = true, @@ -83,53 +83,20 @@ HapPolicyParams g_testPolicyParams = { }; uint64_t g_selfShellTokenId; - -PermissionStateFull g_tddPermReq = { - .permissionName = MANAGE_HAP_TOKEN_ID_PERMISSION, - .isGeneral = true, - .resDeviceID = {"device3"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED} -}; - -PermissionStateFull g_tddPermGet = { - .permissionName = "ohos.permission.GET_SENSITIVE_PERMISSIONS", - .isGeneral = true, - .resDeviceID = {"device3"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED} -}; - -PermissionStateFull g_tddPermRevoke = { - .permissionName = "ohos.permission.REVOKE_SENSITIVE_PERMISSIONS", - .isGeneral = true, - .resDeviceID = {"device3"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED} -}; - -HapInfoParams g_tddHapInfoParams = { - .userID = 1, - .bundleName = "EdmPolicySetTest", - .instIndex = 0, - .appIDDesc = "test2", - .apiVersion = 11, // api version is 11 - .isSystemApp = true -}; - -HapPolicyParams g_tddPolicyParams = { - .apl = APL_SYSTEM_CORE, - .domain = "test.domain2", - .permStateList = {g_tddPermReq, g_tddPermGet, g_tddPermRevoke} -}; +static MockHapToken* g_mock = nullptr; } void EdmPolicySetTest::TearDownTestCase() { - AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_tddHapInfoParams.userID, - g_tddHapInfoParams.bundleName, - g_tddHapInfoParams.instIndex); - AccessTokenKit::DeleteToken(tokenId); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle( + g_testHapInfoParams.userID, g_testHapInfoParams.bundleName, g_testHapInfoParams.instIndex); + TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID); + if (g_mock != nullptr) { + delete g_mock; + g_mock = nullptr; + } + EXPECT_EQ(0, SetSelfTokenID(g_selfShellTokenId)); + TestCommon::ResetTestEvironment(); } void EdmPolicySetTest::SetUp() @@ -144,18 +111,23 @@ void EdmPolicySetTest::TearDown() void EdmPolicySetTest::SetUpTestCase() { g_selfShellTokenId = GetSelfTokenID(); - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_tddHapInfoParams, g_tddPolicyParams); - SetSelfTokenID(tokenIdEx.tokenIDEx); + TestCommon::SetTestEvironment(g_selfShellTokenId); + + std::vector reqPerm; + reqPerm.emplace_back(MANAGE_HAP_TOKEN_ID_PERMISSION); + reqPerm.emplace_back(GET_SENSITIVE_PERMISSIONS); + reqPerm.emplace_back(REVOKE_SENSITIVE_PERMISSIONS); + g_mock = new (std::nothrow) MockHapToken("EdmPolicySetTest", reqPerm); LOGI(ATM_DOMAIN, ATM_TAG, "SetUpTestCase ok."); } /** - * @tc.name: InitUserPolicy002 + * @tc.name: InitUserPolicy001 * @tc.desc: InitUserPolicy failed invalid userList size. * @tc.type: FUNC * @tc.require:Issue Number */ -HWTEST_F(EdmPolicySetTest, InitUserPolicy002, TestSize.Level1) +HWTEST_F(EdmPolicySetTest, InitUserPolicy001, TestSize.Level1) { const int32_t invalidSize = 1025; // 1025 is invalid size. std::vector userList(invalidSize); @@ -165,12 +137,12 @@ HWTEST_F(EdmPolicySetTest, InitUserPolicy002, TestSize.Level1) } /** - * @tc.name: InitUserPolicy003 + * @tc.name: InitUserPolicy002 * @tc.desc: InitUserPolicy failed empty userList. * @tc.type: FUNC * @tc.require:Issue Number */ -HWTEST_F(EdmPolicySetTest, InitUserPolicy003, TestSize.Level1) +HWTEST_F(EdmPolicySetTest, InitUserPolicy002, TestSize.Level1) { std::vector userListEmtpy; std::vector permList = { "ohos.permission.INTERNET" }; @@ -179,12 +151,12 @@ HWTEST_F(EdmPolicySetTest, InitUserPolicy003, TestSize.Level1) } /** - * @tc.name: InitUserPolicy004 + * @tc.name: InitUserPolicy003 * @tc.desc: InitUserPolicy failed empty userList. * @tc.type: FUNC * @tc.require:Issue Number */ -HWTEST_F(EdmPolicySetTest, InitUserPolicy004, TestSize.Level1) +HWTEST_F(EdmPolicySetTest, InitUserPolicy003, TestSize.Level1) { UserState user = {.userId = DEFAULT_ACCOUNT_ID, .isActive = true}; const int32_t invalidSize = 1025; // 1025 is invalid size. @@ -195,12 +167,12 @@ HWTEST_F(EdmPolicySetTest, InitUserPolicy004, TestSize.Level1) } /** - * @tc.name: InitUserPolicy005 + * @tc.name: InitUserPolicy004 * @tc.desc: InitUserPolicy failed empty permList. * @tc.type: FUNC * @tc.require:Issue Number */ -HWTEST_F(EdmPolicySetTest, InitUserPolicy005, TestSize.Level1) +HWTEST_F(EdmPolicySetTest, InitUserPolicy004, TestSize.Level1) { UserState user = {.userId = DEFAULT_ACCOUNT_ID, .isActive = true}; std::vector userList = { user }; @@ -209,46 +181,79 @@ HWTEST_F(EdmPolicySetTest, InitUserPolicy005, TestSize.Level1) EXPECT_EQ(ret, AccessTokenError::ERR_PARAM_INVALID); } + /** - * @tc.name: UpdateUserPolicy001 - * @tc.desc: UpdateUserPolicy failed with - * policy uninitialized and ClearUserPolicy successfully with policy uninitialized. + * @tc.name: InitUserPolicy005 + * @tc.desc: InitUserPolicy and the stock permission status is refreshed according to the policy. * @tc.type: FUNC * @tc.require:Issue Number */ -HWTEST_F(EdmPolicySetTest, UpdateUserPolicy001, TestSize.Level1) +HWTEST_F(EdmPolicySetTest, InitUserPolicy005, TestSize.Level1) { - uint32_t tokenId = AccessTokenKit::GetNativeTokenId("foundation"); - EXPECT_EQ(0, SetSelfTokenID(tokenId)); GTEST_LOG_(INFO) << "permissionSet OK "; + MockNativeToken mock("foundation"); - UserState user = {.userId = DEFAULT_ACCOUNT_ID, .isActive = true}; - const std::vector userList = { user }; - int32_t res = AccessTokenKit::UpdateUserPolicy(userList); - EXPECT_EQ(res, AccessTokenError::ERR_USER_POLICY_NOT_INITIALIZED); + g_testHapInfoParams.userID = MOCK_USER_ID_10001; + AccessTokenIDEx fullIdUser1; + EXPECT_EQ(RET_SUCCESS, + TestCommon::AllocTestHapToken(g_testHapInfoParams, g_testPolicyParams, fullIdUser1)); + g_testHapInfoParams.userID = MOCK_USER_ID_10002; + AccessTokenIDEx fullIdUser2; + EXPECT_EQ(RET_SUCCESS, + TestCommon::AllocTestHapToken(g_testHapInfoParams, g_testPolicyParams, fullIdUser2)); + g_testHapInfoParams.userID = MOCK_USER_ID_10003; + AccessTokenIDEx fullIdUser3; + EXPECT_EQ(RET_SUCCESS, + TestCommon::AllocTestHapToken(g_testHapInfoParams, g_testPolicyParams, fullIdUser3)); - res = AccessTokenKit::ClearUserPolicy(); - EXPECT_EQ(res, RET_SUCCESS); + EXPECT_EQ(AccessTokenKit::VerifyAccessToken(fullIdUser1.tokenIdExStruct.tokenID, LOCATION), + PERMISSION_DENIED); + + UserState user0 = {.userId = -1, .isActive = true}; + UserState user1 = {.userId = MOCK_USER_ID_10001, .isActive = true}; + UserState user2 = {.userId = MOCK_USER_ID_10002, .isActive = false}; + UserState user3 = {.userId = MOCK_USER_ID_10003, .isActive = false}; + + std::vector userList = { user0, user1, user2, user3 }; + std::vector permList = { INTERNET, GET_NETWORK_STATS, LOCATION }; + EXPECT_EQ(RET_SUCCESS, AccessTokenKit::InitUserPolicy(userList, permList)); + + EXPECT_EQ(AccessTokenKit::VerifyAccessToken(fullIdUser1.tokenIdExStruct.tokenID, INTERNET), PERMISSION_GRANTED); + EXPECT_EQ(AccessTokenKit::VerifyAccessToken(fullIdUser2.tokenIdExStruct.tokenID, INTERNET), PERMISSION_DENIED); + EXPECT_EQ(AccessTokenKit::VerifyAccessToken(fullIdUser3.tokenIdExStruct.tokenID, INTERNET), PERMISSION_DENIED); + EXPECT_EQ(AccessTokenKit::VerifyAccessToken(fullIdUser1.tokenIdExStruct.tokenID, LOCATION), + PERMISSION_DENIED); + EXPECT_EQ(AccessTokenKit::VerifyAccessToken(fullIdUser2.tokenIdExStruct.tokenID, LOCATION), + PERMISSION_DENIED); + EXPECT_EQ(AccessTokenKit::VerifyAccessToken(fullIdUser3.tokenIdExStruct.tokenID, LOCATION), + PERMISSION_DENIED); + + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(fullIdUser1.tokenIdExStruct.tokenID)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(fullIdUser2.tokenIdExStruct.tokenID)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(fullIdUser3.tokenIdExStruct.tokenID)); + + EXPECT_EQ(RET_SUCCESS, AccessTokenKit::ClearUserPolicy()); } /** - * @tc.name: InitUserPolicy008 + * @tc.name: InitUserPolicy006 * @tc.desc: Check permission status in the heap. * @tc.type: FUNC * @tc.require:Issue Number */ -HWTEST_F(EdmPolicySetTest, InitUserPolicy008, TestSize.Level1) +HWTEST_F(EdmPolicySetTest, InitUserPolicy006, TestSize.Level1) { - uint32_t tokenId = AccessTokenKit::GetNativeTokenId("foundation"); - EXPECT_EQ(0, SetSelfTokenID(tokenId)); GTEST_LOG_(INFO) << "permissionSet OK "; + MockNativeToken mock("foundation"); g_testHapInfoParams.userID = MOCK_USER_ID_10001; AccessTokenIDEx fullIdUser1; - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(g_testHapInfoParams, g_testPolicyParams, fullIdUser1)); + EXPECT_EQ(RET_SUCCESS, + TestCommon::AllocTestHapToken(g_testHapInfoParams, g_testPolicyParams, fullIdUser1)); g_testHapInfoParams.userID = MOCK_USER_ID_10002; AccessTokenIDEx fullIdUser2; - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(g_testHapInfoParams, g_testPolicyParams, fullIdUser2)); + EXPECT_EQ(RET_SUCCESS, + TestCommon::AllocTestHapToken(g_testHapInfoParams, g_testPolicyParams, fullIdUser2)); UserState user0 = {.userId = -1, .isActive = true}; UserState user1 = {.userId = MOCK_USER_ID_10001, .isActive = true}; @@ -263,70 +268,37 @@ HWTEST_F(EdmPolicySetTest, InitUserPolicy008, TestSize.Level1) EXPECT_EQ(AccessTokenKit::VerifyAccessToken(fullIdUser2.tokenIdExStruct.tokenID, INTERNET), PERMISSION_DENIED); std::vector permStatList; - res = AccessTokenKit::GetReqPermissions(fullIdUser2.tokenIdExStruct.tokenID, permStatList, true); - EXPECT_EQ(RET_SUCCESS, res); + EXPECT_EQ(RET_SUCCESS, AccessTokenKit::GetReqPermissions(fullIdUser2.tokenIdExStruct.tokenID, permStatList, true)); ASSERT_EQ(static_cast(2), permStatList.size()); EXPECT_EQ(INTERNET, permStatList[0].permissionName); EXPECT_EQ(PERMISSION_GRANTED, permStatList[0].grantStatus[0]); - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(fullIdUser1.tokenIdExStruct.tokenID)); - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(fullIdUser2.tokenIdExStruct.tokenID)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(fullIdUser1.tokenIdExStruct.tokenID)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(fullIdUser2.tokenIdExStruct.tokenID)); res = AccessTokenKit::ClearUserPolicy(); EXPECT_EQ(res, 0); } /** - * @tc.name: InitUserPolicy007 - * @tc.desc: InitUserPolicy and the stock permission status is refreshed according to the policy. + * @tc.name: UpdateUserPolicy001 + * @tc.desc: UpdateUserPolicy failed with + * policy uninitialized and ClearUserPolicy successfully with policy uninitialized. * @tc.type: FUNC * @tc.require:Issue Number */ -HWTEST_F(EdmPolicySetTest, InitUserPolicy007, TestSize.Level1) +HWTEST_F(EdmPolicySetTest, UpdateUserPolicy001, TestSize.Level1) { - uint32_t tokenId = AccessTokenKit::GetNativeTokenId("foundation"); - EXPECT_EQ(0, SetSelfTokenID(tokenId)); GTEST_LOG_(INFO) << "permissionSet OK "; + MockNativeToken mock("foundation"); - g_testHapInfoParams.userID = MOCK_USER_ID_10001; - AccessTokenIDEx fullIdUser1; - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(g_testHapInfoParams, g_testPolicyParams, fullIdUser1)); - g_testHapInfoParams.userID = MOCK_USER_ID_10002; - AccessTokenIDEx fullIdUser2; - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(g_testHapInfoParams, g_testPolicyParams, fullIdUser2)); - g_testHapInfoParams.userID = MOCK_USER_ID_10003; - AccessTokenIDEx fullIdUser3; - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(g_testHapInfoParams, g_testPolicyParams, fullIdUser3)); - - EXPECT_EQ(AccessTokenKit::VerifyAccessToken(fullIdUser1.tokenIdExStruct.tokenID, LOCATION), - PERMISSION_DENIED); - - UserState user0 = {.userId = -1, .isActive = true}; - UserState user1 = {.userId = MOCK_USER_ID_10001, .isActive = true}; - UserState user2 = {.userId = MOCK_USER_ID_10002, .isActive = false}; - UserState user3 = {.userId = MOCK_USER_ID_10003, .isActive = false}; - - std::vector userList = { user0, user1, user2, user3 }; - std::vector permList = { INTERNET, GET_NETWORK_STATS, LOCATION }; - int32_t ret = AccessTokenKit::InitUserPolicy(userList, permList); - EXPECT_EQ(ret, 0); - - EXPECT_EQ(AccessTokenKit::VerifyAccessToken(fullIdUser1.tokenIdExStruct.tokenID, INTERNET), PERMISSION_GRANTED); - EXPECT_EQ(AccessTokenKit::VerifyAccessToken(fullIdUser2.tokenIdExStruct.tokenID, INTERNET), PERMISSION_DENIED); - EXPECT_EQ(AccessTokenKit::VerifyAccessToken(fullIdUser3.tokenIdExStruct.tokenID, INTERNET), PERMISSION_DENIED); - EXPECT_EQ(AccessTokenKit::VerifyAccessToken(fullIdUser1.tokenIdExStruct.tokenID, LOCATION), - PERMISSION_DENIED); - EXPECT_EQ(AccessTokenKit::VerifyAccessToken(fullIdUser2.tokenIdExStruct.tokenID, LOCATION), - PERMISSION_DENIED); - EXPECT_EQ(AccessTokenKit::VerifyAccessToken(fullIdUser3.tokenIdExStruct.tokenID, LOCATION), - PERMISSION_DENIED); - - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(fullIdUser1.tokenIdExStruct.tokenID)); - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(fullIdUser2.tokenIdExStruct.tokenID)); - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(fullIdUser3.tokenIdExStruct.tokenID)); + UserState user = {.userId = DEFAULT_ACCOUNT_ID, .isActive = true}; + const std::vector userList = { user }; + int32_t res = AccessTokenKit::UpdateUserPolicy(userList); + EXPECT_EQ(res, AccessTokenError::ERR_USER_POLICY_NOT_INITIALIZED); - int32_t res = AccessTokenKit::ClearUserPolicy(); - EXPECT_EQ(res, 0); + res = AccessTokenKit::ClearUserPolicy(); + EXPECT_EQ(res, RET_SUCCESS); } /** @@ -357,13 +329,16 @@ HWTEST_F(EdmPolicySetTest, UpdateUserPolicy004, TestSize.Level1) { g_testHapInfoParams.userID = MOCK_USER_ID_10001; AccessTokenIDEx fullIdUser1; - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(g_testHapInfoParams, g_testPolicyParams, fullIdUser1)); + EXPECT_EQ(RET_SUCCESS, + TestCommon::AllocTestHapToken(g_testHapInfoParams, g_testPolicyParams, fullIdUser1)); g_testHapInfoParams.userID = MOCK_USER_ID_10002; AccessTokenIDEx fullIdUser2; - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(g_testHapInfoParams, g_testPolicyParams, fullIdUser2)); + EXPECT_EQ(RET_SUCCESS, + TestCommon::AllocTestHapToken(g_testHapInfoParams, g_testPolicyParams, fullIdUser2)); g_testHapInfoParams.userID = MOCK_USER_ID_10003; AccessTokenIDEx fullIdUser3; - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(g_testHapInfoParams, g_testPolicyParams, fullIdUser3)); + EXPECT_EQ(RET_SUCCESS, + TestCommon::AllocTestHapToken(g_testHapInfoParams, g_testPolicyParams, fullIdUser3)); UserState user1 = {.userId = MOCK_USER_ID_10001, .isActive = false}; UserState user2 = {.userId = MOCK_USER_ID_10002, .isActive = true}; @@ -394,9 +369,9 @@ HWTEST_F(EdmPolicySetTest, UpdateUserPolicy004, TestSize.Level1) EXPECT_EQ(AccessTokenKit::VerifyAccessToken(fullIdUser2.tokenIdExStruct.tokenID, LOCATION), PERMISSION_DENIED); - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(fullIdUser1.tokenIdExStruct.tokenID)); - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(fullIdUser2.tokenIdExStruct.tokenID)); - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(fullIdUser3.tokenIdExStruct.tokenID)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(fullIdUser1.tokenIdExStruct.tokenID)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(fullIdUser2.tokenIdExStruct.tokenID)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(fullIdUser3.tokenIdExStruct.tokenID)); int32_t res = AccessTokenKit::ClearUserPolicy(); EXPECT_EQ(res, 0); @@ -419,10 +394,12 @@ HWTEST_F(EdmPolicySetTest, UserPolicyTestForNewHap, TestSize.Level1) g_testHapInfoParams.userID = MOCK_USER_ID_10001; AccessTokenIDEx fullIdUser1; - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(g_testHapInfoParams, g_testPolicyParams, fullIdUser1)); + EXPECT_EQ(RET_SUCCESS, + TestCommon::AllocTestHapToken(g_testHapInfoParams, g_testPolicyParams, fullIdUser1)); g_testHapInfoParams.userID = MOCK_USER_ID_10002; AccessTokenIDEx fullIdUser2; - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(g_testHapInfoParams, g_testPolicyParams, fullIdUser2)); + EXPECT_EQ(RET_SUCCESS, + TestCommon::AllocTestHapToken(g_testHapInfoParams, g_testPolicyParams, fullIdUser2)); EXPECT_EQ(AccessTokenKit::VerifyAccessToken(fullIdUser1.tokenIdExStruct.tokenID, INTERNET), PERMISSION_GRANTED); EXPECT_EQ(AccessTokenKit::VerifyAccessToken(fullIdUser2.tokenIdExStruct.tokenID, INTERNET), PERMISSION_GRANTED); @@ -430,8 +407,8 @@ HWTEST_F(EdmPolicySetTest, UserPolicyTestForNewHap, TestSize.Level1) PERMISSION_DENIED); EXPECT_EQ(AccessTokenKit::VerifyAccessToken(fullIdUser2.tokenIdExStruct.tokenID, LOCATION), PERMISSION_DENIED); - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(fullIdUser1.tokenIdExStruct.tokenID)); - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(fullIdUser2.tokenIdExStruct.tokenID)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(fullIdUser1.tokenIdExStruct.tokenID)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(fullIdUser2.tokenIdExStruct.tokenID)); // update the policy user1.isActive = false; @@ -440,17 +417,19 @@ HWTEST_F(EdmPolicySetTest, UserPolicyTestForNewHap, TestSize.Level1) int32_t ret = AccessTokenKit::UpdateUserPolicy(userListAfter); EXPECT_EQ(ret, 0); g_testHapInfoParams.userID = MOCK_USER_ID_10001; - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(g_testHapInfoParams, g_testPolicyParams, fullIdUser1)); + EXPECT_EQ(RET_SUCCESS, + TestCommon::AllocTestHapToken(g_testHapInfoParams, g_testPolicyParams, fullIdUser1)); g_testHapInfoParams.userID = MOCK_USER_ID_10002; - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(g_testHapInfoParams, g_testPolicyParams, fullIdUser2)); + EXPECT_EQ(RET_SUCCESS, + TestCommon::AllocTestHapToken(g_testHapInfoParams, g_testPolicyParams, fullIdUser2)); EXPECT_EQ(AccessTokenKit::VerifyAccessToken(fullIdUser1.tokenIdExStruct.tokenID, INTERNET), PERMISSION_DENIED); EXPECT_EQ(AccessTokenKit::VerifyAccessToken(fullIdUser2.tokenIdExStruct.tokenID, INTERNET), PERMISSION_DENIED); EXPECT_EQ(AccessTokenKit::VerifyAccessToken(fullIdUser1.tokenIdExStruct.tokenID, LOCATION), PERMISSION_DENIED); EXPECT_EQ(AccessTokenKit::VerifyAccessToken(fullIdUser2.tokenIdExStruct.tokenID, LOCATION), PERMISSION_DENIED); - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(fullIdUser1.tokenIdExStruct.tokenID)); - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(fullIdUser2.tokenIdExStruct.tokenID)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(fullIdUser1.tokenIdExStruct.tokenID)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(fullIdUser2.tokenIdExStruct.tokenID)); EXPECT_EQ(AccessTokenKit::ClearUserPolicy(), 0); } @@ -471,10 +450,12 @@ HWTEST_F(EdmPolicySetTest, UserPolicyTestForClearUserGranted, TestSize.Level1) g_testHapInfoParams.userID = MOCK_USER_ID_10001; AccessTokenIDEx fullIdUser1; - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(g_testHapInfoParams, g_testPolicyParams, fullIdUser1)); + EXPECT_EQ(RET_SUCCESS, + TestCommon::AllocTestHapToken(g_testHapInfoParams, g_testPolicyParams, fullIdUser1)); g_testHapInfoParams.userID = MOCK_USER_ID_10002; AccessTokenIDEx fullIdUser2; - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(g_testHapInfoParams, g_testPolicyParams, fullIdUser2)); + EXPECT_EQ(RET_SUCCESS, + TestCommon::AllocTestHapToken(g_testHapInfoParams, g_testPolicyParams, fullIdUser2)); EXPECT_EQ(AccessTokenKit::VerifyAccessToken(fullIdUser1.tokenIdExStruct.tokenID, INTERNET), PERMISSION_GRANTED); EXPECT_EQ(AccessTokenKit::VerifyAccessToken(fullIdUser2.tokenIdExStruct.tokenID, INTERNET), PERMISSION_DENIED); @@ -500,8 +481,8 @@ HWTEST_F(EdmPolicySetTest, UserPolicyTestForClearUserGranted, TestSize.Level1) EXPECT_EQ(AccessTokenKit::VerifyAccessToken(fullIdUser1.tokenIdExStruct.tokenID, INTERNET), PERMISSION_DENIED); EXPECT_EQ(AccessTokenKit::VerifyAccessToken(fullIdUser2.tokenIdExStruct.tokenID, INTERNET), PERMISSION_GRANTED); - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(fullIdUser1.tokenIdExStruct.tokenID)); - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(fullIdUser2.tokenIdExStruct.tokenID)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(fullIdUser1.tokenIdExStruct.tokenID)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(fullIdUser2.tokenIdExStruct.tokenID)); int32_t res = AccessTokenKit::ClearUserPolicy(); EXPECT_EQ(res, 0); @@ -517,10 +498,12 @@ HWTEST_F(EdmPolicySetTest, ClearUserPolicy001, TestSize.Level1) { g_testHapInfoParams.userID = MOCK_USER_ID_10002; AccessTokenIDEx fullIdUser2; - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(g_testHapInfoParams, g_testPolicyParams, fullIdUser2)); + EXPECT_EQ(RET_SUCCESS, + TestCommon::AllocTestHapToken(g_testHapInfoParams, g_testPolicyParams, fullIdUser2)); g_testHapInfoParams.userID = MOCK_USER_ID_10001; AccessTokenIDEx fullIdUser1; - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(g_testHapInfoParams, g_testPolicyParams, fullIdUser1)); + EXPECT_EQ(RET_SUCCESS, + TestCommon::AllocTestHapToken(g_testHapInfoParams, g_testPolicyParams, fullIdUser1)); UserState user1 = {.userId = MOCK_USER_ID_10001, .isActive = false}; UserState user2 = {.userId = MOCK_USER_ID_10002, .isActive = false}; @@ -540,8 +523,8 @@ HWTEST_F(EdmPolicySetTest, ClearUserPolicy001, TestSize.Level1) EXPECT_EQ(AccessTokenKit::VerifyAccessToken(fullIdUser1.tokenIdExStruct.tokenID, INTERNET), PERMISSION_GRANTED); EXPECT_EQ(AccessTokenKit::VerifyAccessToken(fullIdUser2.tokenIdExStruct.tokenID, INTERNET), PERMISSION_GRANTED); - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(fullIdUser1.tokenIdExStruct.tokenID)); - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(fullIdUser2.tokenIdExStruct.tokenID)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(fullIdUser1.tokenIdExStruct.tokenID)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(fullIdUser2.tokenIdExStruct.tokenID)); } @@ -562,7 +545,8 @@ HWTEST_F(EdmPolicySetTest, UserPolicyForUpdateHapTokenTest, TestSize.Level1) }; g_testHapInfoParams.userID = MOCK_USER_ID_10001; AccessTokenIDEx fullIdUser1; - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(g_testHapInfoParams, testPolicyParams1, fullIdUser1)); + EXPECT_EQ(RET_SUCCESS, + TestCommon::AllocTestHapToken(g_testHapInfoParams, testPolicyParams1, fullIdUser1)); UserState user1 = {.userId = MOCK_USER_ID_10001, .isActive = false}; std::vector userList = { user1}; @@ -580,13 +564,14 @@ HWTEST_F(EdmPolicySetTest, UserPolicyForUpdateHapTokenTest, TestSize.Level1) info.appIDDesc = "TEST"; info.apiVersion = 12; info.isSystemApp = false; - int32_t res = AccessTokenKit::UpdateHapToken(fullIdUser1, info, testPolicyParams2); - EXPECT_EQ(res, 0); + { + MockNativeToken mock("foundation"); + EXPECT_EQ(RET_SUCCESS, AccessTokenKit::UpdateHapToken(fullIdUser1, info, testPolicyParams2)); + } EXPECT_EQ(AccessTokenKit::VerifyAccessToken(fullIdUser1.tokenIdExStruct.tokenID, INTERNET), PERMISSION_DENIED); - res = AccessTokenKit::ClearUserPolicy(); - EXPECT_EQ(res, 0); + EXPECT_EQ(RET_SUCCESS, AccessTokenKit::ClearUserPolicy()); EXPECT_EQ(AccessTokenKit::VerifyAccessToken(fullIdUser1.tokenIdExStruct.tokenID, INTERNET), PERMISSION_GRANTED); - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(fullIdUser1.tokenIdExStruct.tokenID)); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(fullIdUser1.tokenIdExStruct.tokenID)); } \ No newline at end of file diff --git a/interfaces/innerkits/accesstoken/test/unittest/src/edm_policy_set_test.h b/interfaces/innerkits/accesstoken/test/unittest/EdmPolicyTest/edm_policy_set_test.h similarity index 100% rename from interfaces/innerkits/accesstoken/test/unittest/src/edm_policy_set_test.h rename to interfaces/innerkits/accesstoken/test/unittest/EdmPolicyTest/edm_policy_set_test.h diff --git a/interfaces/innerkits/accesstoken/test/unittest/HapAttributeTest/get_hap_dlp_flag_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/HapAttributeTest/get_hap_dlp_flag_test.cpp index 14d93ee134129976da830e578f1af57cd78dfe7e..8800bdfa9bd5d4f0cb403097846e0e702dbfa2a0 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/HapAttributeTest/get_hap_dlp_flag_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/HapAttributeTest/get_hap_dlp_flag_test.cpp @@ -33,68 +33,19 @@ using namespace testing::ext; namespace OHOS { namespace Security { namespace AccessToken { -namespace { -static AccessTokenID g_selfTokenId = 0; static const int INVALID_DLP_TOKEN_FLAG = -1; -static const std::string TEST_BUNDLE_NAME = "ohos"; -static const int TEST_USER_ID = 0; -static constexpr int32_t DEFAULT_API_VERSION = 8; -HapInfoParams g_infoManagerTestInfoParms = TestCommon::GetInfoManagerTestInfoParms(); -HapPolicyParams g_infoManagerTestPolicyPrams = TestCommon::GetInfoManagerTestPolicyPrams(); -}; void GetHapDlpFlagTest::SetUpTestCase() { - g_selfTokenId = GetSelfTokenID(); - - // clean up test cases - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, - TestCommon::GetTestPolicyParams()); - SetSelfTokenID(tokenIdEx.tokenIDEx); } void GetHapDlpFlagTest::TearDownTestCase() { - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - SetSelfTokenID(g_selfTokenId); } void GetHapDlpFlagTest::SetUp() { LOGI(ATM_DOMAIN, ATM_TAG, "SetUp ok."); - - setuid(0); - HapInfoParams info = { - .userID = TEST_USER_ID, - .bundleName = TEST_BUNDLE_NAME, - .instIndex = 0, - .appIDDesc = "appIDDesc", - .apiVersion = DEFAULT_API_VERSION - }; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "domain" - }; - TestCommon::TestPreparePermDefList(policy); - TestCommon::TestPreparePermStateList(policy); - - AccessTokenKit::AllocHapToken(info, policy); } void GetHapDlpFlagTest::TearDown() diff --git a/interfaces/innerkits/accesstoken/test/unittest/HapAttributeTest/get_permission_flag_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/HapAttributeTest/get_permission_flag_test.cpp index 23ec9a6620dd74605cf7fc2b97dc67d90409b395..e9eb03f38288b229d9beaafb38fbf15725c86c81 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/HapAttributeTest/get_permission_flag_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/HapAttributeTest/get_permission_flag_test.cpp @@ -34,57 +34,49 @@ namespace OHOS { namespace Security { namespace AccessToken { namespace { -static AccessTokenID g_selfTokenId = 0; +static uint64_t g_selfTokenId = 0; static const std::string TEST_BUNDLE_NAME = "ohos"; static const unsigned int TEST_TOKENID_INVALID = 0; static const int TEST_USER_ID = 0; static constexpr int32_t DEFAULT_API_VERSION = 8; static const int INVALID_PERMNAME_LEN = 260; static const int CYCLE_TIMES = 100; -HapInfoParams g_infoManagerTestNormalInfoParms = TestCommon::GetInfoManagerTestNormalInfoParms(); -HapInfoParams g_infoManagerTestSystemInfoParms = TestCommon::GetInfoManagerTestSystemInfoParms(); -HapPolicyParams g_infoManagerTestPolicyPrams = TestCommon::GetInfoManagerTestPolicyPrams(); -}; +static const std::string PERMISSION_MICROPHONE = "ohos.permission.MICROPHONE"; +static const std::string GRANT_SENSITIVE_PERMISSION = "ohos.permission.GRANT_SENSITIVE_PERMISSIONS"; +static MockHapToken* g_mock = nullptr; +} void GetPermissionFlagTest::SetUpTestCase() { g_selfTokenId = GetSelfTokenID(); + TestCommon::SetTestEvironment(g_selfTokenId); // clean up test cases - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestNormalInfoParms.userID, - g_infoManagerTestNormalInfoParms.bundleName, - g_infoManagerTestNormalInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestSystemInfoParms.userID, - g_infoManagerTestSystemInfoParms.bundleName, - g_infoManagerTestSystemInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestSystemInfoParms, - TestCommon::GetTestPolicyParams()); - SetSelfTokenID(tokenIdEx.tokenIDEx); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + if (tokenID != INVALID_TOKENID) { + TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID); + } + + std::vector reqPerm; + reqPerm.emplace_back(GRANT_SENSITIVE_PERMISSION); + g_mock = new (std::nothrow) MockHapToken("GetPermissionFlagTest", reqPerm, true); } void GetPermissionFlagTest::TearDownTestCase() { - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestNormalInfoParms.userID, - g_infoManagerTestNormalInfoParms.bundleName, - g_infoManagerTestNormalInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestSystemInfoParms.userID, - g_infoManagerTestSystemInfoParms.bundleName, - g_infoManagerTestSystemInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - + // clean up test cases + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + if (tokenID != INVALID_TOKENID) { + TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID); + } + if (g_mock != nullptr) { + delete g_mock; + g_mock = nullptr; + } SetSelfTokenID(g_selfTokenId); + TestCommon::ResetTestEvironment(); } void GetPermissionFlagTest::SetUp() @@ -104,14 +96,29 @@ void GetPermissionFlagTest::SetUp() .apl = APL_NORMAL, .domain = "domain" }; - TestCommon::TestPreparePermDefList(policy); - TestCommon::TestPreparePermStateList(policy); + PermissionStateFull permStatMicro = { + .permissionName = PERMISSION_MICROPHONE, + .isGeneral = true, + .resDeviceID = {"device3"}, + .grantStatus = {PermissionState::PERMISSION_DENIED}, + .grantFlags = {PermissionFlag::PERMISSION_USER_SET} + }; + + policy.permStateList.emplace_back(permStatMicro); - AccessTokenKit::AllocHapToken(info, policy); + AccessTokenIDEx tokenIdEx = {0}; + EXPECT_EQ(RET_SUCCESS, TestCommon::AllocTestHapToken(info, policy, tokenIdEx)); + ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); } void GetPermissionFlagTest::TearDown() { + // clean up test cases + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + if (tokenID != INVALID_TOKENID) { + TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID); + } } /** @@ -123,18 +130,17 @@ void GetPermissionFlagTest::TearDown() HWTEST_F(GetPermissionFlagTest, GetPermissionFlagFuncTest001, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "GetPermissionFlagFuncTest001"); - - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; ASSERT_NE(INVALID_TOKENID, tokenID); - int ret = AccessTokenKit::GrantPermission(tokenID, "ohos.permission.MICROPHONE", PERMISSION_USER_FIXED); - ASSERT_EQ(RET_SUCCESS, ret); + ASSERT_EQ( + RET_SUCCESS, AccessTokenKit::GrantPermission(tokenID, "ohos.permission.MICROPHONE", PERMISSION_USER_FIXED)); uint32_t flag; - ret = AccessTokenKit::GetPermissionFlag(tokenID, "ohos.permission.MICROPHONE", flag); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GetPermissionFlag(tokenID, PERMISSION_MICROPHONE, flag)); ASSERT_EQ(PERMISSION_USER_FIXED, flag); - ASSERT_EQ(RET_SUCCESS, ret); - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -147,7 +153,8 @@ HWTEST_F(GetPermissionFlagTest, GetPermissionFlagAbnormalTest001, TestSize.Level { LOGI(ATM_DOMAIN, ATM_TAG, "GetPermissionFlagAbnormalTest001"); - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; ASSERT_NE(INVALID_TOKENID, tokenID); uint32_t flag; @@ -161,11 +168,10 @@ HWTEST_F(GetPermissionFlagTest, GetPermissionFlagAbnormalTest001, TestSize.Level ret = AccessTokenKit::GetPermissionFlag(tokenID, invalidPerm, flag); ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); - ret = AccessTokenKit::GetPermissionFlag(TEST_TOKENID_INVALID, "ohos.permission.MICROPHONE", flag); + ret = AccessTokenKit::GetPermissionFlag(TEST_TOKENID_INVALID, PERMISSION_MICROPHONE, flag); ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); - ret = AccessTokenKit::DeleteToken(tokenID); - ASSERT_EQ(RET_SUCCESS, ret); + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); ret = AccessTokenKit::GetPermissionFlag(tokenID, "ohos.permission.ALPHA", flag); ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, ret); @@ -181,18 +187,17 @@ HWTEST_F(GetPermissionFlagTest, GetPermissionFlagSpecTest001, TestSize.Level0) { LOGI(ATM_DOMAIN, ATM_TAG, "GetPermissionFlagSpecTest001"); - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; ASSERT_NE(INVALID_TOKENID, tokenID); uint32_t flag; for (int i = 0; i < CYCLE_TIMES; i++) { - int32_t ret = AccessTokenKit::GrantPermission(tokenID, "ohos.permission.MICROPHONE", PERMISSION_USER_FIXED); - ASSERT_EQ(RET_SUCCESS, ret); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GrantPermission(tokenID, PERMISSION_MICROPHONE, PERMISSION_USER_FIXED)); - ret = AccessTokenKit::GetPermissionFlag(tokenID, "ohos.permission.MICROPHONE", flag); - ASSERT_EQ(RET_SUCCESS, ret); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GetPermissionFlag(tokenID, PERMISSION_MICROPHONE, flag)); ASSERT_EQ(PERMISSION_USER_FIXED, flag); } - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -205,18 +210,16 @@ HWTEST_F(GetPermissionFlagTest, GetPermissionFlagSpecTest002, TestSize.Level0) { LOGI(ATM_DOMAIN, ATM_TAG, "GetPermissionFlagSpecTest002"); - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestNormalInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); + bool isSystemApp = false; + std::vector reqPerm; + reqPerm.emplace_back(GRANT_SENSITIVE_PERMISSION); + MockHapToken mock("GetPermissionFlagSpecTest002", reqPerm, isSystemApp); - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; uint32_t flag; - int ret = AccessTokenKit::GetPermissionFlag(tokenID, "ohos.permission.MICROPHONE", flag); - ASSERT_EQ(ERR_NOT_SYSTEM_APP, ret); - - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); + ASSERT_EQ(ERR_NOT_SYSTEM_APP, AccessTokenKit::GetPermissionFlag(tokenID, PERMISSION_MICROPHONE, flag)); } /** @@ -229,22 +232,20 @@ HWTEST_F(GetPermissionFlagTest, GetPermissionFlagSpecTest003, TestSize.Level0) { LOGI(ATM_DOMAIN, ATM_TAG, "GetPermissionFlagSpecTest003"); - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestSystemInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); + bool isSystemApp = true; + std::vector reqPerm; + reqPerm.emplace_back(GRANT_SENSITIVE_PERMISSION); + MockHapToken mock("GetPermissionFlagSpecTest003", reqPerm, isSystemApp); - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; ASSERT_NE(INVALID_TOKENID, tokenID); - int ret = AccessTokenKit::GrantPermission(tokenID, "ohos.permission.MICROPHONE", PERMISSION_USER_FIXED); - ASSERT_EQ(RET_SUCCESS, ret); + ASSERT_EQ( + RET_SUCCESS, AccessTokenKit::GrantPermission(tokenID, "ohos.permission.MICROPHONE", PERMISSION_USER_FIXED)); uint32_t flag; - ret = AccessTokenKit::GetPermissionFlag(tokenID, "ohos.permission.MICROPHONE", flag); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GetPermissionFlag(tokenID, PERMISSION_MICROPHONE, flag)); ASSERT_EQ(PERMISSION_USER_FIXED, flag); - ASSERT_EQ(RET_SUCCESS, ret); - - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); } } // namespace AccessToken } // namespace Security diff --git a/interfaces/innerkits/accesstoken/test/unittest/HapAttributeTest/get_permissions_status_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/HapAttributeTest/get_permissions_status_test.cpp index b6c20e92719b91e12fa32f2f7451440f525b7512..2174649a0dadbe3eb3cd18de9d5a1547b5f27ea5 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/HapAttributeTest/get_permissions_status_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/HapAttributeTest/get_permissions_status_test.cpp @@ -34,77 +34,43 @@ namespace OHOS { namespace Security { namespace AccessToken { namespace { -static AccessTokenID g_selfTokenId = 0; +static uint64_t g_selfTokenId = 0; static const std::string TEST_BUNDLE_NAME = "ohos"; static const int TEST_USER_ID = 0; static constexpr int32_t DEFAULT_API_VERSION = 8; static constexpr int32_t TOKENID_NOT_EXIST = 123; -static const std::string TEST_PERMISSION_NAME_BETA = "ohos.permission.BETA"; -HapInfoParams g_infoManagerTestNormalInfoParms = TestCommon::GetInfoManagerTestNormalInfoParms(); -HapInfoParams g_infoManagerTestSystemInfoParms = TestCommon::GetInfoManagerTestSystemInfoParms(); -HapInfoParams g_infoManagerTestInfoParms = TestCommon::GetInfoManagerTestInfoParms(); -HapPolicyParams g_infoManagerTestPolicyPrams = TestCommon::GetInfoManagerTestPolicyPrams(); +static MockHapToken* g_mock = nullptr; }; void GetPermissionsStatusTest::SetUpTestCase() { g_selfTokenId = GetSelfTokenID(); - - // clean up test cases - AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenId); - - tokenId = AccessTokenKit::GetHapTokenID(g_infoManagerTestNormalInfoParms.userID, - g_infoManagerTestNormalInfoParms.bundleName, - g_infoManagerTestNormalInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenId); - - tokenId = AccessTokenKit::GetHapTokenID(g_infoManagerTestSystemInfoParms.userID, - g_infoManagerTestSystemInfoParms.bundleName, - g_infoManagerTestSystemInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenId); - - tokenId = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenId); - - TestCommon::GetNativeTokenTest(); + TestCommon::SetTestEvironment(g_selfTokenId); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID; + if (tokenId != INVALID_TOKENID) { + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenId)); + } + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.GET_SENSITIVE_PERMISSIONS"); + reqPerm.emplace_back("ohos.permission.DISABLE_PERMISSION_DIALOG"); + g_mock = new (std::nothrow) MockHapToken("GetPermissionsStatusTest", reqPerm, true); } void GetPermissionsStatusTest::TearDownTestCase() { + // clean up test cases + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + if (tokenID != INVALID_TOKENID) { + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); + } + if (g_mock != nullptr) { + delete g_mock; + g_mock = nullptr; + } SetSelfTokenID(g_selfTokenId); -} - -void PreparePermStateListExt1(HapPolicyParams &policy) -{ - PermissionStateFull permStatBeta = { - .permissionName = "ohos.permission.BETA", - .isGeneral = true, - .resDeviceID = {"device"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED} - }; - - PermissionStateFull permTestState5 = { - .permissionName = "ohos.permission.GET_SENSITIVE_PERMISSIONS", - .isGeneral = true, - .resDeviceID = {"local"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED} - }; - - PermissionStateFull permTestState6 = { - .permissionName = "ohos.permission.DISABLE_PERMISSION_DIALOG", - .isGeneral = true, - .resDeviceID = {"local"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED} - }; - policy.permStateList.emplace_back(permStatBeta); - policy.permStateList.emplace_back(permTestState5); - policy.permStateList.emplace_back(permTestState6); + TestCommon::ResetTestEvironment(); } void PreparePermStateList1(HapPolicyParams &policy) @@ -116,36 +82,38 @@ void PreparePermStateList1(HapPolicyParams &policy) .grantStatus = {PermissionState::PERMISSION_DENIED}, .grantFlags = {PermissionFlag::PERMISSION_DEFAULT_FLAG}, }; - - PermissionStateFull permTestState3 = { + PermissionStateFull permTestState2 = { .permissionName = "ohos.permission.WRITE_CALENDAR", .isGeneral = true, .resDeviceID = {"local"}, .grantStatus = {PermissionState::PERMISSION_DENIED}, .grantFlags = {PermissionFlag::PERMISSION_USER_FIXED} }; - + PermissionStateFull permTestState3 = { + .permissionName = "ohos.permission.GET_SENSITIVE_PERMISSIONS", + .isGeneral = true, + .resDeviceID = {"local"}, + .grantStatus = {PermissionState::PERMISSION_GRANTED}, + .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED} + }; + PermissionStateFull permTestState4 = { + .permissionName = "ohos.permission.DISABLE_PERMISSION_DIALOG", + .isGeneral = true, + .resDeviceID = {"local"}, + .grantStatus = {PermissionState::PERMISSION_GRANTED}, + .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED} + }; policy.permStateList.emplace_back(permTestState1); + policy.permStateList.emplace_back(permTestState2); policy.permStateList.emplace_back(permTestState3); - PreparePermStateListExt1(policy); -} + policy.permStateList.emplace_back(permTestState4); -void PreparePermDefList1(HapPolicyParams &policy) -{ - PermissionDef permissionDefBeta; - permissionDefBeta.permissionName = "ohos.permission.BETA"; - permissionDefBeta.bundleName = TEST_BUNDLE_NAME; - permissionDefBeta.grantMode = GrantMode::SYSTEM_GRANT; - permissionDefBeta.availableLevel = APL_NORMAL; - permissionDefBeta.provisionEnable = false; - permissionDefBeta.distributedSceneEnable = false; - - policy.permList.emplace_back(permissionDefBeta); + policy.aclRequestedList.emplace_back(permTestState3.permissionName); + policy.aclRequestedList.emplace_back(permTestState4.permissionName); } void GetPermissionsStatusTest::SetUp() { - selfTokenId_ = GetSelfTokenID(); HapInfoParams info = { .userID = TEST_USER_ID, .bundleName = TEST_BUNDLE_NAME, @@ -159,29 +127,19 @@ void GetPermissionsStatusTest::SetUp() .apl = APL_NORMAL, .domain = "domain" }; - PreparePermDefList1(policy); PreparePermStateList1(policy); - AccessTokenKit::AllocHapToken(info, policy); - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); + AccessTokenIDEx tokenIdEx = {0}; + EXPECT_EQ(RET_SUCCESS, TestCommon::AllocTestHapToken(info, policy, tokenIdEx)); + ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); } void GetPermissionsStatusTest::TearDown() { - AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenId); - tokenId = AccessTokenKit::GetHapTokenID(g_infoManagerTestNormalInfoParms.userID, - g_infoManagerTestNormalInfoParms.bundleName, - g_infoManagerTestNormalInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenId); - - tokenId = AccessTokenKit::GetHapTokenID(g_infoManagerTestSystemInfoParms.userID, - g_infoManagerTestSystemInfoParms.bundleName, - g_infoManagerTestSystemInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenId); - EXPECT_EQ(0, SetSelfTokenID(selfTokenId_)); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID; + if (tokenId != INVALID_TOKENID) { + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenId)); + } } /** @@ -192,10 +150,9 @@ void GetPermissionsStatusTest::TearDown() */ HWTEST_F(GetPermissionsStatusTest, GetPermissionsStatusFuncTest001, TestSize.Level1) { - AccessTokenIDEx tokenIDEx = AccessTokenKit::GetHapTokenIDEx(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenID tokenID = tokenIDEx.tokenIdExStruct.tokenID; + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; ASSERT_NE(INVALID_TOKENID, tokenID); - EXPECT_EQ(0, SetSelfTokenID(tokenIDEx.tokenIDEx)); std::vector permsList; PermissionListState tmpA = { @@ -226,7 +183,7 @@ HWTEST_F(GetPermissionsStatusTest, GetPermissionsStatusFuncTest001, TestSize.Lev permsList.emplace_back(tmpE); ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GetPermissionsStatus(tokenID, permsList)); ASSERT_EQ(DYNAMIC_OPER, permsList[0].state); - ASSERT_EQ(SETTING_OPER, permsList[1].state); + ASSERT_EQ(DYNAMIC_OPER, permsList[1].state); ASSERT_EQ(INVALID_OPER, permsList[2].state); ASSERT_EQ(INVALID_OPER, permsList[3].state); ASSERT_EQ(INVALID_OPER, permsList[4].state); @@ -240,10 +197,9 @@ HWTEST_F(GetPermissionsStatusTest, GetPermissionsStatusFuncTest001, TestSize.Lev */ HWTEST_F(GetPermissionsStatusTest, GetPermissionsStatusFuncTest002, TestSize.Level1) { - AccessTokenIDEx tokenIDEx = AccessTokenKit::GetHapTokenIDEx(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenID tokenID = tokenIDEx.tokenIdExStruct.tokenID; + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; ASSERT_NE(INVALID_TOKENID, tokenID); - EXPECT_EQ(0, SetSelfTokenID(tokenIDEx.tokenIDEx)); std::vector permsList; PermissionListState tmpA = { @@ -296,10 +252,9 @@ HWTEST_F(GetPermissionsStatusTest, GetPermissionsStatusFuncTest002, TestSize.Lev */ HWTEST_F(GetPermissionsStatusTest, GetPermissionsStatusAbnormalTest001, TestSize.Level1) { - AccessTokenIDEx tokenIDEx = AccessTokenKit::GetHapTokenIDEx(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenID tokenID = tokenIDEx.tokenIdExStruct.tokenID; + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; ASSERT_NE(INVALID_TOKENID, tokenID); - EXPECT_EQ(0, SetSelfTokenID(tokenIDEx.tokenIDEx)); std::vector permsList; ASSERT_EQ(ERR_PARAM_INVALID, AccessTokenKit::GetPermissionsStatus(tokenID, permsList)); @@ -340,11 +295,12 @@ HWTEST_F(GetPermissionsStatusTest, GetPermissionsStatusAbnormalTest002, TestSize */ HWTEST_F(GetPermissionsStatusTest, GetPermissionsStatusAbnormalTest003, TestSize.Level1) { - AccessTokenIDEx tokenIDEx = {0}; - tokenIDEx = AccessTokenKit::AllocHapToken(g_infoManagerTestSystemInfoParms, g_infoManagerTestPolicyPrams); - AccessTokenID tokenID = tokenIDEx.tokenIdExStruct.tokenID; + std::vector reqPerm; + MockHapToken mock("GetPermissionsStatusAbnormalTest003", reqPerm, true); + + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; ASSERT_NE(INVALID_TOKENID, tokenID); - EXPECT_EQ(0, SetSelfTokenID(tokenIDEx.tokenIDEx)); std::vector permsList; PermissionListState tmpA = { @@ -369,11 +325,13 @@ HWTEST_F(GetPermissionsStatusTest, GetPermissionsStatusAbnormalTest003, TestSize */ HWTEST_F(GetPermissionsStatusTest, GetPermissionsStatusSpecTest001, TestSize.Level1) { - AccessTokenIDEx tokenIDEx = {0}; - tokenIDEx = AccessTokenKit::AllocHapToken(g_infoManagerTestNormalInfoParms, g_infoManagerTestPolicyPrams); - AccessTokenID tokenID = tokenIDEx.tokenIdExStruct.tokenID; + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.GET_SENSITIVE_PERMISSIONS"); + MockHapToken mock("GetPermissionsStatusSpecTest001", reqPerm, false); + + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; ASSERT_NE(INVALID_TOKENID, tokenID); - EXPECT_EQ(0, SetSelfTokenID(tokenIDEx.tokenIDEx)); std::vector permsList; PermissionListState tmpA = { @@ -395,7 +353,8 @@ HWTEST_F(GetPermissionsStatusTest, GetPermissionsStatusSpecTest001, TestSize.Lev */ HWTEST_F(GetPermissionsStatusTest, GetPermissionsStatusSpecTest002, TestSize.Level1) { - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; ASSERT_NE(INVALID_TOKENID, tokenID); std::vector permsList; diff --git a/interfaces/innerkits/accesstoken/test/unittest/HapAttributeTest/get_permissions_status_test.h b/interfaces/innerkits/accesstoken/test/unittest/HapAttributeTest/get_permissions_status_test.h index f7a0f40720c8cdb3856a43c5425694113fa7db51..60dd60474eb2f784294c816420da70a3e14947c4 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/HapAttributeTest/get_permissions_status_test.h +++ b/interfaces/innerkits/accesstoken/test/unittest/HapAttributeTest/get_permissions_status_test.h @@ -32,7 +32,6 @@ public: static void TearDownTestCase(); void SetUp(); void TearDown(); - uint64_t selfTokenId_; }; } // namespace AccessToken } // namespace Security diff --git a/interfaces/innerkits/accesstoken/test/unittest/HapAttributeTest/get_self_permissions_state_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/HapAttributeTest/get_self_permissions_state_test.cpp deleted file mode 100644 index 0384d965737c82b6eb479532f6e7655efa87338b..0000000000000000000000000000000000000000 --- a/interfaces/innerkits/accesstoken/test/unittest/HapAttributeTest/get_self_permissions_state_test.cpp +++ /dev/null @@ -1,171 +0,0 @@ -/* - * Copyright (c) 2024 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 "get_self_permissions_state_test.h" -#include "gtest/gtest.h" -#include -#include - -#include "access_token.h" -#include "access_token_error.h" -#include "accesstoken_common_log.h" -#include "accesstoken_service_ipc_interface_code.h" -#include "permission_grant_info.h" -#include "permission_state_change_info_parcel.h" -#include "string_ex.h" -#include "test_common.h" -#include "tokenid_kit.h" -#include "token_setproc.h" - -using namespace testing::ext; -namespace OHOS { -namespace Security { -namespace AccessToken { -namespace { -static AccessTokenID g_selfTokenId = 0; -static const std::string TEST_BUNDLE_NAME = "ohos"; -static const int TEST_USER_ID = 0; -static constexpr int32_t DEFAULT_API_VERSION = 8; -static const int32_t INDEX_ZERO = 0; -static const int32_t INDEX_ONE = 1; -static const int32_t INDEX_TWO = 2; -static const int32_t INDEX_THREE = 3; -static const int32_t INDEX_FOUR = 4; -HapInfoParams g_infoManagerTestInfoParms = TestCommon::GetInfoManagerTestInfoParms(); -HapPolicyParams g_infoManagerTestPolicyPrams = TestCommon::GetInfoManagerTestPolicyPrams(); -}; - -uint64_t GetNativeTokenTestGetSelfPermissionsState(const char *processName, const char **perms, int32_t permNum) -{ - uint64_t tokenId; - NativeTokenInfoParams infoInstance = { - .dcapsNum = 0, - .permsNum = permNum, - .aclsNum = 0, - .dcaps = nullptr, - .perms = perms, - .acls = nullptr, - .aplStr = "system_core", - .processName = processName, - }; - - tokenId = GetAccessTokenId(&infoInstance); - AccessTokenKit::ReloadNativeTokenInfo(); - return tokenId; -} - -void NativeTokenGetSelfPermissionsState() -{ - uint64_t tokenID; - const char **perms = new const char *[5]; // 5: array size - perms[INDEX_ZERO] = "ohos.permission.DISTRIBUTED_DATASYNC"; - perms[INDEX_ONE] = "ohos.permission.GRANT_SENSITIVE_PERMISSIONS"; - perms[INDEX_TWO] = "ohos.permission.REVOKE_SENSITIVE_PERMISSIONS"; - perms[INDEX_THREE] = "ohos.permission.GET_SENSITIVE_PERMISSIONS"; - perms[INDEX_FOUR] = "ohos.permission.DISABLE_PERMISSION_DIALOG"; - - tokenID = GetNativeTokenTestGetSelfPermissionsState("TestCase", perms, 5); // 5: array size - EXPECT_EQ(0, SetSelfTokenID(tokenID)); - delete[] perms; -} - -void GetSelfPermissionsStateTest::SetUpTestCase() -{ - g_selfTokenId = GetSelfTokenID(); - - // clean up test cases - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - NativeTokenGetSelfPermissionsState(); -} - -void GetSelfPermissionsStateTest::TearDownTestCase() -{ - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - SetSelfTokenID(g_selfTokenId); -} - -void GetSelfPermissionsStateTest::SetUp() -{ - LOGI(ATM_DOMAIN, ATM_TAG, "SetUp ok."); - - setuid(0); - HapInfoParams info = { - .userID = TEST_USER_ID, - .bundleName = TEST_BUNDLE_NAME, - .instIndex = 0, - .appIDDesc = "appIDDesc", - .apiVersion = DEFAULT_API_VERSION - }; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "domain" - }; - TestCommon::TestPreparePermDefList(policy); - TestCommon::TestPreparePermStateList(policy); - - AccessTokenKit::AllocHapToken(info, policy); -} - -void GetSelfPermissionsStateTest::TearDown() -{ -} - -/** - * @tc.name: GetSelfPermissionsStateAbnormalTest001 - * @tc.desc: get self permissions state with wrong token type. - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(GetSelfPermissionsStateTest, GetSelfPermissionsStateAbnormalTest001, TestSize.Level1) -{ - LOGI(ATM_DOMAIN, ATM_TAG, "GetSelfPermissionsStateAbnormalTest001"); - AccessTokenID tokenID = TestCommon::AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); - HapBaseInfo hapBaseInfo = { - .userID = g_infoManagerTestInfoParms.userID, - .bundleName = g_infoManagerTestInfoParms.bundleName, - .instIndex = g_infoManagerTestInfoParms.instIndex, - }; - - std::vector permsList; - PermissionListState tmp = { - .permissionName = g_infoManagerTestPolicyPrams.permStateList[0].permissionName, - .state = BUTT_OPER - }; - permsList.emplace_back(tmp); - - // test dialog isn't forbiddedn - ASSERT_EQ(0, AccessTokenKit::SetPermDialogCap(hapBaseInfo, false)); - SetSelfTokenID(tokenID); - PermissionGrantInfo info; - ASSERT_EQ(INVALID_OPER, AccessTokenKit::GetSelfPermissionsState(permsList, info)); -} -} // namespace AccessToken -} // namespace Security -} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/accesstoken/test/unittest/HapAttributeTest/permission_request_toggle_status_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/HapAttributeTest/permission_request_toggle_status_test.cpp index cb1bfeaaf297889930e1395ccde6e7cb421c0da5..6f5452f5eb7a2a1331df0307f7740042fb43cd97 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/HapAttributeTest/permission_request_toggle_status_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/HapAttributeTest/permission_request_toggle_status_test.cpp @@ -34,10 +34,11 @@ namespace OHOS { namespace Security { namespace AccessToken { namespace { -static AccessTokenID g_selfTokenId = 0; +static uint64_t g_selfTokenId = 0; static const std::string TEST_BUNDLE_NAME = "ohos"; static const int TEST_USER_ID = 0; static constexpr int32_t DEFAULT_API_VERSION = 8; +static MockHapToken* g_mock = nullptr; HapInfoParams g_infoManagerTestNormalInfoParms = TestCommon::GetInfoManagerTestNormalInfoParms(); HapInfoParams g_infoManagerTestSystemInfoParms = TestCommon::GetInfoManagerTestSystemInfoParms(); HapPolicyParams g_infoManagerTestPolicyPrams = TestCommon::GetInfoManagerTestPolicyPrams(); @@ -46,42 +47,31 @@ HapPolicyParams g_infoManagerTestPolicyPrams = TestCommon::GetInfoManagerTestPol void PermissionRequestToggleStatusTest::SetUpTestCase() { g_selfTokenId = GetSelfTokenID(); + TestCommon::SetTestEvironment(g_selfTokenId); // clean up test cases - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestNormalInfoParms.userID, - g_infoManagerTestNormalInfoParms.bundleName, - g_infoManagerTestNormalInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestSystemInfoParms.userID, - g_infoManagerTestSystemInfoParms.bundleName, - g_infoManagerTestSystemInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestSystemInfoParms, - TestCommon::GetTestPolicyParams()); - SetSelfTokenID(tokenIdEx.tokenIDEx); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + TestCommon::DeleteTestHapToken(tokenID); + + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.GET_SENSITIVE_PERMISSIONS"); + reqPerm.emplace_back("ohos.permission.DISABLE_PERMISSION_DIALOG"); + g_mock = new (std::nothrow) MockHapToken("PermissionRequestToggleStatusTest", reqPerm, true); } void PermissionRequestToggleStatusTest::TearDownTestCase() { - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestNormalInfoParms.userID, - g_infoManagerTestNormalInfoParms.bundleName, - g_infoManagerTestNormalInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestSystemInfoParms.userID, - g_infoManagerTestSystemInfoParms.bundleName, - g_infoManagerTestSystemInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - SetSelfTokenID(g_selfTokenId); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + TestCommon::DeleteTestHapToken(tokenID); + + if (g_mock != nullptr) { + delete g_mock; + g_mock = nullptr; + } + EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId)); + TestCommon::ResetTestEvironment(); } void PermissionRequestToggleStatusTest::SetUp() @@ -101,14 +91,18 @@ void PermissionRequestToggleStatusTest::SetUp() .apl = APL_NORMAL, .domain = "domain" }; - TestCommon::TestPreparePermDefList(policy); TestCommon::TestPreparePermStateList(policy); - AccessTokenKit::AllocHapToken(info, policy); + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ(RET_SUCCESS, TestCommon::AllocTestHapToken(info, policy, tokenIdEx)); + ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIdExStruct.tokenID); } void PermissionRequestToggleStatusTest::TearDown() { + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + TestCommon::DeleteTestHapToken(tokenID); } /** @@ -149,11 +143,9 @@ HWTEST_F(PermissionRequestToggleStatusTest, SetPermissionRequestToggleStatusAbno HWTEST_F(PermissionRequestToggleStatusTest, SetPermissionRequestToggleStatus001, TestSize.Level0) { LOGI(ATM_DOMAIN, ATM_TAG, "SetPermissionRequestToggleStatus001"); - - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestNormalInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.DISABLE_PERMISSION_DIALOG"); + MockHapToken mock("SetPermissionRequestToggleStatus001", reqPerm, false); uint32_t status = PermissionRequestToggleStatus::CLOSED; int32_t ret = AccessTokenKit::SetPermissionRequestToggleStatus("ohos.permission.MICROPHONE", status, @@ -163,22 +155,18 @@ HWTEST_F(PermissionRequestToggleStatusTest, SetPermissionRequestToggleStatus001, /** * @tc.name: SetPermissionRequestToggleStatus002 - * @tc.desc: SetPermissionRequestToggleStatus caller is a system app without related permissions. + * @tc.desc: SetPermissionRequestToggleStatus caller is a system app without permissions. * @tc.type: FUNC * @tc.require: Issue Number */ HWTEST_F(PermissionRequestToggleStatusTest, SetPermissionRequestToggleStatus002, TestSize.Level0) { LOGI(ATM_DOMAIN, ATM_TAG, "SetPermissionRequestToggleStatus002"); - - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestSystemInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); + std::vector reqPerm; + MockHapToken mock("SetPermissionRequestToggleStatus002", reqPerm, true); int32_t selfUid = getuid(); setuid(10001); // 10001： UID - uint32_t status = PermissionRequestToggleStatus::CLOSED; int32_t ret = AccessTokenKit::SetPermissionRequestToggleStatus("ohos.permission.MICROPHONE", status, g_infoManagerTestSystemInfoParms.userID); @@ -195,49 +183,16 @@ HWTEST_F(PermissionRequestToggleStatusTest, SetPermissionRequestToggleStatus002, /** * @tc.name: SetPermissionRequestToggleStatusSpecTest003 - * @tc.desc: SetPermissionRequestToggleStatus caller is a system app with related permissions. + * @tc.desc: SetPermissionRequestToggleStatus caller is a system app with permissions. * @tc.type: FUNC * @tc.require: Issue Number */ HWTEST_F(PermissionRequestToggleStatusTest, SetPermissionRequestToggleStatusSpecTest003, TestSize.Level0) { LOGI(ATM_DOMAIN, ATM_TAG, "SetPermissionRequestToggleStatusSpecTest003"); - - AccessTokenIDEx tokenIdEx = {0}; - - PermissionDef infoManagerTestPermDef = { - .permissionName = "ohos.permission.DISABLE_PERMISSION_DIALOG_TEST", - .bundleName = "accesstoken_test", - .grantMode = 1, - .availableLevel = APL_NORMAL, - .label = "label3", - .labelId = 1, - .description = "open the door", - .descriptionId = 1, - .availableType = MDM - }; - - PermissionStateFull infoManagerTestState = { - .permissionName = "ohos.permission.DISABLE_PERMISSION_DIALOG", - .isGeneral = true, - .resDeviceID = {"local3"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {1} - }; - - HapPolicyParams infoManagerTestPolicyPrams = { - .apl = APL_NORMAL, - .domain = "test.domain3", - .permList = {infoManagerTestPermDef}, - .permStateList = {infoManagerTestState} - }; - - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestSystemInfoParms, infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); - - int32_t selfUid = getuid(); - setuid(10001); // 10001： UID + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.DISABLE_PERMISSION_DIALOG"); + MockHapToken mock("SetPermissionRequestToggleStatusSpecTest003", reqPerm, true); uint32_t status = PermissionRequestToggleStatus::CLOSED; int32_t ret = AccessTokenKit::SetPermissionRequestToggleStatus("ohos.permission.MICROPHONE", status, @@ -248,9 +203,6 @@ HWTEST_F(PermissionRequestToggleStatusTest, SetPermissionRequestToggleStatusSpec ret = AccessTokenKit::SetPermissionRequestToggleStatus("ohos.permission.MICROPHONE", status, g_infoManagerTestSystemInfoParms.userID); ASSERT_EQ(RET_SUCCESS, ret); - - // restore environment - setuid(selfUid); } /** @@ -285,11 +237,9 @@ HWTEST_F(PermissionRequestToggleStatusTest, GetPermissionRequestToggleStatusAbno HWTEST_F(PermissionRequestToggleStatusTest, GetPermissionRequestToggleStatusSpecTest001, TestSize.Level0) { LOGI(ATM_DOMAIN, ATM_TAG, "GetPermissionRequestToggleStatusSpecTest001"); - - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestNormalInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.DISABLE_PERMISSION_DIALOG"); + MockHapToken mock("GetPermissionRequestToggleStatusSpecTest001", reqPerm, false); uint32_t status; int32_t ret = AccessTokenKit::GetPermissionRequestToggleStatus("ohos.permission.MICROPHONE", status, @@ -299,18 +249,15 @@ HWTEST_F(PermissionRequestToggleStatusTest, GetPermissionRequestToggleStatusSpec /** * @tc.name: GetPermissionRequestToggleStatusSpecTest002 - * @tc.desc: GetPermissionRequestToggleStatus caller is a system app without related permissions. + * @tc.desc: GetPermissionRequestToggleStatus caller is a system app without permissions. * @tc.type: FUNC * @tc.require: Issue Number */ HWTEST_F(PermissionRequestToggleStatusTest, GetPermissionRequestToggleStatusSpecTest002, TestSize.Level0) { LOGI(ATM_DOMAIN, ATM_TAG, "GetPermissionRequestToggleStatusSpecTest002"); - - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestSystemInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); + std::vector reqPerm; + MockHapToken mock("GetPermissionRequestToggleStatusSpecTest002", reqPerm, true); int32_t selfUid = getuid(); setuid(10001); // 10001： UID @@ -324,62 +271,6 @@ HWTEST_F(PermissionRequestToggleStatusTest, GetPermissionRequestToggleStatusSpec setuid(selfUid); } -static void AllocAndSetHapToken(void) -{ - AccessTokenIDEx tokenIdEx = {0}; - - PermissionDef infoManagerTestPermDef1 = { - .permissionName = "ohos.permission.DISABLE_PERMISSION_DIALOG_TEST", - .bundleName = "accesstoken_test", - .grantMode = 1, - .availableLevel = APL_NORMAL, - .label = "label3", - .labelId = 1, - .description = "open the door", - .descriptionId = 1, - .availableType = MDM - }; - - PermissionStateFull infoManagerTestState1 = { - .permissionName = "ohos.permission.DISABLE_PERMISSION_DIALOG", - .isGeneral = true, - .resDeviceID = {"local3"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {1} - }; - - PermissionDef infoManagerTestPermDef2 = { - .permissionName = "ohos.permission.GET_SENSITIVE_PERMISSIONS_TEST", - .bundleName = "accesstoken_test", - .grantMode = 1, - .availableLevel = APL_NORMAL, - .label = "label3", - .labelId = 1, - .description = "open the door", - .descriptionId = 1, - .availableType = MDM - }; - - PermissionStateFull infoManagerTestState2 = { - .permissionName = "ohos.permission.GET_SENSITIVE_PERMISSIONS", - .isGeneral = true, - .resDeviceID = {"local3"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {1} - }; - - HapPolicyParams infoManagerTestPolicyPrams = { - .apl = APL_NORMAL, - .domain = "test.domain3", - .permList = {infoManagerTestPermDef1, infoManagerTestPermDef2}, - .permStateList = {infoManagerTestState1, infoManagerTestState2} - }; - - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestSystemInfoParms, infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); -} - /** * @tc.name: GetPermissionRequestToggleStatusSpecTest003 * @tc.desc: GetPermissionRequestToggleStatus caller is a system app with related permissions. @@ -389,11 +280,10 @@ static void AllocAndSetHapToken(void) HWTEST_F(PermissionRequestToggleStatusTest, GetPermissionRequestToggleStatusSpecTest003, TestSize.Level0) { LOGI(ATM_DOMAIN, ATM_TAG, "GetPermissionRequestToggleStatusSpecTest003"); - - AllocAndSetHapToken(); - - int32_t selfUid = getuid(); - setuid(10001); // 10001： UID + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.DISABLE_PERMISSION_DIALOG"); + reqPerm.emplace_back("ohos.permission.GET_SENSITIVE_PERMISSIONS"); + MockHapToken mock("GetPermissionRequestToggleStatusSpecTest002", reqPerm, true); // Set a closed status value. uint32_t status = PermissionRequestToggleStatus::CLOSED; @@ -419,9 +309,6 @@ HWTEST_F(PermissionRequestToggleStatusTest, GetPermissionRequestToggleStatusSpec g_infoManagerTestSystemInfoParms.userID); ASSERT_EQ(RET_SUCCESS, ret); ASSERT_EQ(PermissionRequestToggleStatus::OPEN, getStatus); - - // restore environment - setuid(selfUid); } } // namespace AccessToken } // namespace Security diff --git a/interfaces/innerkits/accesstoken/test/unittest/HapAttributeTest/user_policy_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/HapAttributeTest/user_policy_test.cpp deleted file mode 100644 index 37cb159ade3372d97adf79c41243f2b0e7b1617f..0000000000000000000000000000000000000000 --- a/interfaces/innerkits/accesstoken/test/unittest/HapAttributeTest/user_policy_test.cpp +++ /dev/null @@ -1,132 +0,0 @@ -/* - * Copyright (c) 2024 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 "user_policy_test.h" -#include "gtest/gtest.h" -#include -#include - -#include "access_token.h" -#include "access_token_error.h" -#include "accesstoken_common_log.h" -#include "accesstoken_service_ipc_interface_code.h" -#include "permission_grant_info.h" -#include "permission_state_change_info_parcel.h" -#include "string_ex.h" -#include "test_common.h" -#include "tokenid_kit.h" -#include "token_setproc.h" - -using namespace testing::ext; -namespace OHOS { -namespace Security { -namespace AccessToken { -namespace { -static AccessTokenID g_selfTokenId = 0; -static const std::string TEST_BUNDLE_NAME = "ohos"; -static const int TEST_USER_ID = 0; -static const int32_t INDEX_ZERO = 0; -static constexpr int32_t DEFAULT_API_VERSION = 8; -HapInfoParams g_infoManagerTestInfoParms = TestCommon::GetInfoManagerTestInfoParms(); -HapPolicyParams g_infoManagerTestPolicyPrams = TestCommon::GetInfoManagerTestPolicyPrams(); -}; - -void UserPolicyTest::SetUpTestCase() -{ - g_selfTokenId = GetSelfTokenID(); - - // clean up test cases - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, - TestCommon::GetTestPolicyParams()); - SetSelfTokenID(tokenIdEx.tokenIDEx); -} - -void UserPolicyTest::TearDownTestCase() -{ - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - SetSelfTokenID(g_selfTokenId); -} - -void UserPolicyTest::SetUp() -{ - LOGI(ATM_DOMAIN, ATM_TAG, "SetUp ok."); - - setuid(0); - HapInfoParams info = { - .userID = TEST_USER_ID, - .bundleName = TEST_BUNDLE_NAME, - .instIndex = 0, - .appIDDesc = "appIDDesc", - .apiVersion = DEFAULT_API_VERSION - }; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "domain" - }; - TestCommon::TestPreparePermDefList(policy); - TestCommon::TestPreparePermStateList(policy); - - AccessTokenKit::AllocHapToken(info, policy); -} - -void UserPolicyTest::TearDown() -{ -} - -/** - * @tc.name: UserPolicyFuncTest001 - * @tc.desc: UserPolicyTest. - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(UserPolicyTest, UserPolicyFuncTest001, TestSize.Level1) -{ - LOGI(ATM_DOMAIN, ATM_TAG, "UserPolicyFuncTest001"); - - setuid(0); - const char **perms = new const char *[1]; - perms[INDEX_ZERO] = "ohos.permission.GET_SENSITIVE_PERMISSIONS"; - uint64_t tokenID = TestCommon::GetNativeToken("TestCase", perms, 1); - EXPECT_EQ(0, SetSelfTokenID(tokenID)); - delete[] perms; - UserState user = {.userId = 100, .isActive = true}; // 100 is userId - const std::vector userList = { user }; - const std::vector permList = { "ohos.permission.INTERNET" }; - int32_t ret = AccessTokenKit::InitUserPolicy(userList, permList); - EXPECT_EQ(ret, 0); - ret = AccessTokenKit::UpdateUserPolicy(userList); - EXPECT_EQ(ret, 0); - ret = AccessTokenKit::ClearUserPolicy(); - EXPECT_EQ(ret, 0); -} -} // namespace AccessToken -} // namespace Security -} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/accesstoken/test/unittest/HapTokenTest/alloc_hap_token_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/HapTokenTest/alloc_hap_token_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..d8d286e83d25df1cffc761d38408da31afae104f --- /dev/null +++ b/interfaces/innerkits/accesstoken/test/unittest/HapTokenTest/alloc_hap_token_test.cpp @@ -0,0 +1,702 @@ +/* + * Copyright (c) 2024 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 "alloc_hap_token_test.h" +#include "gtest/gtest.h" +#include + +#include "access_token.h" +#include "access_token_error.h" +#include "accesstoken_common_log.h" +#include "accesstoken_service_ipc_interface_code.h" +#include "nativetoken_kit.h" +#include "permission_grant_info.h" +#include "permission_state_change_info_parcel.h" +#include "string_ex.h" +#include "test_common.h" +#include "tokenid_kit.h" +#include "token_setproc.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace AccessToken { +namespace { +static constexpr int32_t DEFAULT_API_VERSION = 8; +static uint64_t g_selfTokenId = 0; +static const int32_t INDEX_ZERO = 0; +static const int32_t INDEX_ONE = 1; +static const int INVALID_BUNDLENAME_LEN = 260; +static const int INVALID_APPIDDESC_LEN = 10244; +static const int INVALID_LABEL_LEN = 260; +static const int INVALID_DESCRIPTION_LEN = 260; +static const int INVALID_PERMNAME_LEN = 260; +static const int CYCLE_TIMES = 100; +static const int INVALID_DLP_TYPE = 4; +static MockNativeToken* g_mock; + +HapInfoParams g_infoManagerTestInfoParms = { + .userID = 1, + .bundleName = "accesstoken_test", + .instIndex = 0, + .appIDDesc = "test3", + .apiVersion = DEFAULT_API_VERSION, + .appDistributionType = "enterprise_mdm" +}; + +PermissionDef g_infoManagerTestPermDef1 = { + .permissionName = "ohos.permission.test1", + .bundleName = "accesstoken_test", + .grantMode = 1, + .availableLevel = APL_NORMAL, + .label = "label3", + .labelId = 1, + .description = "open the door", + .descriptionId = 1, + .availableType = MDM +}; + +PermissionDef g_infoManagerTestPermDef2 = { + .permissionName = "ohos.permission.test2", + .bundleName = "accesstoken_test", + .grantMode = 1, + .availableLevel = APL_NORMAL, + .label = "label3", + .labelId = 1, + .description = "break the door", + .descriptionId = 1, +}; + +PermissionStateFull g_infoManagerTestState1 = { + .permissionName = "ohos.permission.test1", + .isGeneral = true, + .resDeviceID = {"local3"}, + .grantStatus = {PermissionState::PERMISSION_GRANTED}, + .grantFlags = {1} +}; + +PermissionStateFull g_infoManagerTestState2 = { + .permissionName = "ohos.permission.test2", + .isGeneral = false, + .resDeviceID = {"device 1", "device 2"}, + .grantStatus = {PermissionState::PERMISSION_GRANTED, PermissionState::PERMISSION_GRANTED}, + .grantFlags = {1, 2} +}; + +HapPolicyParams g_infoManagerTestPolicyPrams = { + .apl = APL_NORMAL, + .domain = "test.domain3", + .permList = {g_infoManagerTestPermDef1, g_infoManagerTestPermDef2}, + .permStateList = {g_infoManagerTestState1, g_infoManagerTestState2} +}; +}; + +void AllocHapTokenTest::SetUpTestCase() +{ + g_selfTokenId = GetSelfTokenID(); + TestCommon::SetTestEvironment(g_selfTokenId); + + g_mock = new (std::nothrow) MockNativeToken("foundation"); + + // make test case clean + AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, + g_infoManagerTestInfoParms.bundleName, + g_infoManagerTestInfoParms.instIndex); + AccessTokenKit::DeleteToken(tokenID); +} + +void AllocHapTokenTest::TearDownTestCase() +{ + if (g_mock != nullptr) { + delete g_mock; + g_mock = nullptr; + } + EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId)); + TestCommon::ResetTestEvironment(); +} + +AccessTokenID AllocHapTokenTest::AllocTestToken( + const HapInfoParams& hapInfo, const HapPolicyParams& hapPolicy) const +{ + AccessTokenIDEx tokenIdEx = {0}; + tokenIdEx = AccessTokenKit::AllocHapToken(hapInfo, hapPolicy); + return tokenIdEx.tokenIdExStruct.tokenID; +} + +unsigned int AllocHapTokenTest::GetAccessTokenID(int userID, const std::string& bundleName, int instIndex) +{ + return AccessTokenKit::GetHapTokenID(userID, bundleName, instIndex); +} + +void AllocHapTokenTest::DeleteTestToken() const +{ + AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, + g_infoManagerTestInfoParms.bundleName, + g_infoManagerTestInfoParms.instIndex); + int ret = AccessTokenKit::DeleteToken(tokenID); + if (tokenID != 0) { + ASSERT_EQ(RET_SUCCESS, ret); + } +} + +void AllocHapTokenTest::GetDlpFlagTest(const HapInfoParams& info, const HapPolicyParams& policy, int flag) +{ + int32_t ret; + HapTokenInfo hapTokenInfoRes; + uint32_t tokenID = GetAccessTokenID(info.userID, info.bundleName, 2); + if (tokenID != 0) { + ret = AccessTokenKit::DeleteToken(tokenID); + } + AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(info, policy); + EXPECT_NE(INVALID_TOKENID, tokenIdEx.tokenIdExStruct.tokenID); + ret = AccessTokenKit::GetHapTokenInfo(tokenIdEx.tokenIdExStruct.tokenID, hapTokenInfoRes); + EXPECT_EQ(ret, RET_SUCCESS); + EXPECT_EQ(hapTokenInfoRes.dlpType, flag); + if (flag == DLP_COMMON) { + EXPECT_EQ(AccessTokenKit::GetHapDlpFlag(tokenIdEx.tokenIdExStruct.tokenID), 0); + } else { + EXPECT_EQ(AccessTokenKit::GetHapDlpFlag(tokenIdEx.tokenIdExStruct.tokenID), 1); + } + ret = AccessTokenKit::DeleteToken(tokenIdEx.tokenIdExStruct.tokenID); + EXPECT_EQ(RET_SUCCESS, ret); + GTEST_LOG_(INFO) << "tokenID :" << tokenIdEx.tokenIdExStruct.tokenID; + ret = AccessTokenKit::GetHapTokenInfo(tokenIdEx.tokenIdExStruct.tokenID, hapTokenInfoRes); + EXPECT_EQ(ret, AccessTokenError::ERR_TOKENID_NOT_EXIST); +} + +void AllocHapTokenTest::SetUp() +{ + LOGI(ATM_DOMAIN, ATM_TAG, "SetUp ok."); + AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, + g_infoManagerTestInfoParms.bundleName, + g_infoManagerTestInfoParms.instIndex); + AccessTokenKit::DeleteToken(tokenID); +} + +void AllocHapTokenTest::TearDown() +{ +} + +/** + * @tc.name: AllocHapToken001 + * @tc.desc: alloc a tokenId successfully, delete it successfully the first time and fail to delete it again. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(AllocHapTokenTest, AllocHapToken001, TestSize.Level1) +{ + AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + GTEST_LOG_(INFO) << "tokenID :" << tokenID; + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); + ASSERT_NE(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); +} + +/** + * @tc.name: AllocHapToken002 + * @tc.desc: alloc a tokenId with the same info and policy repeatly, + * tokenId will change. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(AllocHapTokenTest, AllocHapToken002, TestSize.Level1) +{ + AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); + GTEST_LOG_(INFO) << "tokenID :" << tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + + AccessTokenID tokenID1 = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); + ASSERT_NE(INVALID_TOKENID, tokenID1); + ASSERT_NE(tokenID, tokenID1); + ASSERT_NE(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID1)); +} + +/** + * @tc.name: AllocHapToken003 + * @tc.desc: cannot alloc a tokenId with invalid bundlename. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(AllocHapTokenTest, AllocHapToken003, TestSize.Level1) +{ + std::string invalidBundleName (INVALID_BUNDLENAME_LEN, 'x'); + std::string bundle = g_infoManagerTestInfoParms.bundleName; + + DeleteTestToken(); + GTEST_LOG_(INFO) << "get hap token info:" << invalidBundleName.length(); + + g_infoManagerTestInfoParms.bundleName = invalidBundleName; + AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); + ASSERT_EQ(INVALID_TOKENID, tokenID); + + tokenID = GetAccessTokenID(g_infoManagerTestInfoParms.userID, + g_infoManagerTestInfoParms.bundleName, + g_infoManagerTestInfoParms.instIndex); + ASSERT_EQ(INVALID_TOKENID, tokenID); + ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, AccessTokenKit::DeleteToken(tokenID)); + + g_infoManagerTestInfoParms.bundleName = bundle; + + DeleteTestToken(); +} + +/** + * @tc.name: AllocHapToken004 + * @tc.desc: cannot alloc a tokenId with invalid apl. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(AllocHapTokenTest, AllocHapToken004, TestSize.Level1) +{ + ATokenAplEnum typeBackUp = g_infoManagerTestPolicyPrams.apl; + DeleteTestToken(); + + g_infoManagerTestPolicyPrams.apl = (ATokenAplEnum)5; + AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); + ASSERT_EQ(INVALID_TOKENID, tokenID); + + tokenID = GetAccessTokenID(g_infoManagerTestInfoParms.userID, + g_infoManagerTestInfoParms.bundleName, + g_infoManagerTestInfoParms.instIndex); + ASSERT_EQ(INVALID_TOKENID, tokenID); + + ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, AccessTokenKit::DeleteToken(tokenID)); + g_infoManagerTestPolicyPrams.apl = typeBackUp; + + DeleteTestToken(); +} + +/** + * @tc.name: AllocHapToken005 + * @tc.desc: can alloc a tokenId when bundlename in permdef is different with bundlename in info. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(AllocHapTokenTest, AllocHapToken005, TestSize.Level1) +{ + std::string backUpPermission = g_infoManagerTestPolicyPrams.permList[INDEX_ONE].permissionName; + std::string bundleNameBackUp = g_infoManagerTestPolicyPrams.permList[INDEX_ONE].bundleName; + ATokenAvailableTypeEnum typeBakup = g_infoManagerTestPolicyPrams.permList[INDEX_ONE].availableType; + DeleteTestToken(); + + g_infoManagerTestPolicyPrams.permList[INDEX_ONE].bundleName = "invalid_bundleName"; + g_infoManagerTestPolicyPrams.permList[INDEX_ONE].permissionName = "ohos.permission.testtmp01"; + g_infoManagerTestPolicyPrams.permList[INDEX_ONE].availableType = MDM; + AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); + ASSERT_NE(INVALID_TOKENID, tokenID); + + PermissionDef permDefResult; + int ret = AccessTokenKit::GetDefPermission( + g_infoManagerTestPolicyPrams.permList[INDEX_ONE].permissionName, permDefResult); + ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, ret); + ASSERT_NE(permDefResult.availableType, MDM); + ret = AccessTokenKit::GetDefPermission( + g_infoManagerTestPolicyPrams.permList[INDEX_ONE].permissionName, permDefResult); + ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, ret); + g_infoManagerTestPolicyPrams.permList[INDEX_ONE].bundleName = bundleNameBackUp; + g_infoManagerTestPolicyPrams.permList[INDEX_ONE].permissionName = backUpPermission; + g_infoManagerTestPolicyPrams.permList[INDEX_ONE].availableType = typeBakup; + + DeleteTestToken(); +} + +/** + * @tc.name: AllocHapToken006 + * @tc.desc: can alloc a tokenId with a invalid permList permissionName. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(AllocHapTokenTest, AllocHapToken006, TestSize.Level1) +{ + std::string backUp = g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName; + DeleteTestToken(); + + const std::string invalidPermissionName (INVALID_PERMNAME_LEN, 'x'); + g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = invalidPermissionName; + AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); + ASSERT_NE(INVALID_TOKENID, tokenID); + + PermissionDef permDefResultBeta; + int ret = AccessTokenKit::GetDefPermission(invalidPermissionName, permDefResultBeta); + ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); + ret = AccessTokenKit::GetDefPermission( + g_infoManagerTestPolicyPrams.permList[INDEX_ONE].permissionName, permDefResultBeta); + ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, ret); + g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = backUp; + + DeleteTestToken(); +} + +/** + * @tc.name: AllocHapToken007 + * @tc.desc: can alloc a tokenId with invalid permdef. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(AllocHapTokenTest, AllocHapToken007, TestSize.Level1) +{ + std::string backUp = g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].bundleName; + std::string backUpPermission = g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName; + DeleteTestToken(); + + const std::string invalidBundleName (INVALID_BUNDLENAME_LEN, 'x'); + + g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = "ohos.permission.testtmp02"; + g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].bundleName = invalidBundleName; + AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); + ASSERT_NE(INVALID_TOKENID, tokenID); + + PermissionDef permDefResultBeta; + int ret = AccessTokenKit::GetDefPermission( + g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName, permDefResultBeta); + ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, ret); + ret = AccessTokenKit::GetDefPermission( + g_infoManagerTestPolicyPrams.permList[INDEX_ONE].permissionName, permDefResultBeta); + ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, ret); + g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].bundleName = backUp; + g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = backUpPermission; + + DeleteTestToken(); +} + +/** + * @tc.name: AllocHapToken008 + * @tc.desc: can alloc a tokenId with invalid permdef. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(AllocHapTokenTest, AllocHapToken008, TestSize.Level1) +{ + std::string backUp = g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].label; + std::string backUpPermission = g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName; + DeleteTestToken(); + + const std::string invalidLabel (INVALID_LABEL_LEN, 'x'); + g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = "ohos.permission.testtmp03"; + g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].label = invalidLabel; + AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); + ASSERT_NE(INVALID_TOKENID, tokenID); + + PermissionDef permDefResultBeta; + int ret = AccessTokenKit::GetDefPermission( + g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName, permDefResultBeta); + ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, ret); + ret = AccessTokenKit::GetDefPermission( + g_infoManagerTestPolicyPrams.permList[INDEX_ONE].permissionName, permDefResultBeta); + ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, ret); + g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].label = backUp; + g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = backUpPermission; + + DeleteTestToken(); +} + +/** + * @tc.name: AllocHapToken009 + * @tc.desc: can alloc a tokenId with invalid permdef. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(AllocHapTokenTest, AllocHapToken009, TestSize.Level1) +{ + std::string backUp = g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].description; + std::string backUpPermission = g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName; + DeleteTestToken(); + + const std::string invalidDescription (INVALID_DESCRIPTION_LEN, 'x'); + + g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = "ohos.permission.testtmp04"; + g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].description = invalidDescription; + AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); + ASSERT_NE(INVALID_TOKENID, tokenID); + + PermissionDef permDefResultBeta; + int ret = AccessTokenKit::GetDefPermission( + g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName, permDefResultBeta); + ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, ret); + ret = AccessTokenKit::GetDefPermission( + g_infoManagerTestPolicyPrams.permList[INDEX_ONE].permissionName, permDefResultBeta); + ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, ret); + + g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].description = backUp; + g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = backUpPermission; + + DeleteTestToken(); +} + +static bool ExistInVector(vector array, unsigned int value) +{ + vector::iterator it = find(array.begin(), array.end(), value); + if (it != array.end()) { + return true; + } else { + return false; + } +} + +/** + * @tc.name: AllocHapToken010 + * @tc.desc: alloc and delete in a loop. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(AllocHapTokenTest, AllocHapToken010, TestSize.Level1) +{ + int ret; + bool exist = false; + int allocFlag = 0; + int deleteFlag = 0; + + DeleteTestToken(); + vector obj; + for (int i = 0; i < CYCLE_TIMES; i++) { + AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); + + exist = ExistInVector(obj, tokenID); + if (exist) { + allocFlag = 1; + } + obj.push_back(tokenID); + + ret = AccessTokenKit::DeleteToken(tokenID); + if (RET_SUCCESS != ret) { + deleteFlag = 1; + } + } + ASSERT_EQ(allocFlag, 0); + ASSERT_EQ(deleteFlag, 0); +} + +/** + * @tc.name: AllocHapToken011 + * @tc.desc: cannot alloc a tokenId with invalid appIDDesc. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(AllocHapTokenTest, AllocHapToken011, TestSize.Level1) +{ + std::string invalidAppIDDesc (INVALID_APPIDDESC_LEN, 'x'); + std::string backup = g_infoManagerTestInfoParms.appIDDesc; + + DeleteTestToken(); + + g_infoManagerTestInfoParms.appIDDesc = invalidAppIDDesc; + AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); + ASSERT_EQ(INVALID_TOKENID, tokenID); + g_infoManagerTestInfoParms.appIDDesc = backup; +} + +/** + * @tc.name: AllocHapToken012 + * @tc.desc: cannot alloc a tokenId with invalid bundleName. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(AllocHapTokenTest, AllocHapToken012, TestSize.Level1) +{ + std::string backup = g_infoManagerTestInfoParms.bundleName; + + g_infoManagerTestInfoParms.bundleName = ""; + AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); + ASSERT_EQ(INVALID_TOKENID, tokenID); + g_infoManagerTestInfoParms.bundleName = backup; +} + +/** + * @tc.name: AllocHapToken013 + * @tc.desc: cannot alloc a tokenId with invalid appIDDesc. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(AllocHapTokenTest, AllocHapToken013, TestSize.Level1) +{ + std::string backup = g_infoManagerTestInfoParms.appIDDesc; + + g_infoManagerTestInfoParms.appIDDesc = ""; + AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); + ASSERT_EQ(INVALID_TOKENID, tokenID); + g_infoManagerTestInfoParms.appIDDesc = backup; +} + +/** + * @tc.name: AllocHapToken014 + * @tc.desc: can alloc a tokenId with permList permissionName as "". + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(AllocHapTokenTest, AllocHapToken014, TestSize.Level1) +{ + std::string backup = g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName; + + g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = ""; + AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); + PermissionDef permDefResultBeta; + ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, AccessTokenKit::GetDefPermission("", permDefResultBeta)); + g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = backup; + + DeleteTestToken(); +} + +/** + * @tc.name: AllocHapToken015 + * @tc.desc: can alloc a tokenId with permList bundleName as "". + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(AllocHapTokenTest, AllocHapToken015, TestSize.Level1) +{ + std::string backup = g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].bundleName; + std::string backUpPermission = g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName; + + g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].bundleName = ""; + g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = "ohos.permission.testtmp05"; + AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); + + PermissionDef permDefResultBeta; + int ret = AccessTokenKit::GetDefPermission( + g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName, permDefResultBeta); + ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, ret); + ret = AccessTokenKit::GetDefPermission( + g_infoManagerTestPolicyPrams.permList[INDEX_ONE].permissionName, permDefResultBeta); + ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, ret); + g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].bundleName = backup; + g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = backUpPermission; + + DeleteTestToken(); +} + +/** + * @tc.name: AllocHapToken016 + * @tc.desc: can alloc a tokenId with label as "". + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(AllocHapTokenTest, AllocHapToken016, TestSize.Level1) +{ + std::string backup = g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].label; + std::string backUpPermission = g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName; + + g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].label = ""; + g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = "ohos.permission.testtmp06"; + AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); + + PermissionDef permDefResult; + int ret = AccessTokenKit::GetDefPermission( + g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName, permDefResult); + ASSERT_EQ(ret, AccessTokenError::ERR_PERMISSION_NOT_EXIST); + g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].label = backup; + g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = backUpPermission; + + DeleteTestToken(); +} + +/** + * @tc.name: AllocHapToken017 + * @tc.desc: cannot alloc a tokenId with invalid permdef. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(AllocHapTokenTest, AllocHapToken017, TestSize.Level1) +{ + std::string backUpPermission = g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName; + std::string backupDec = g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].description; + + g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].description = ""; + g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = "ohos.permission.testtmp07"; + AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); + + PermissionDef permDefResult; + int ret = AccessTokenKit::GetDefPermission( + g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName, permDefResult); + ASSERT_EQ(ret, AccessTokenError::ERR_PERMISSION_NOT_EXIST); + g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].description = backupDec; + g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = backUpPermission; + + DeleteTestToken(); +} + +/** + * @tc.name: AllocHapToken018 + * @tc.desc: alloc a tokenId with vaild dlptype. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(AllocHapTokenTest, AllocHapToken018, TestSize.Level1) +{ + HapPolicyParams infoManagerTestPolicyPrams = { + .apl = APL_NORMAL, + .domain = "test.domain", + .permList = {}, + .permStateList = {} + }; + const HapInfoParams infoManagerTestInfoParms1 = { + .userID = 1, + .bundleName = "dlp_test1", + .instIndex = 0, + .dlpType = DLP_COMMON, + .appIDDesc = "test3", + .apiVersion = DEFAULT_API_VERSION + }; + const HapInfoParams infoManagerTestInfoParms2 = { + .userID = 1, + .bundleName = "dlp_test2", + .instIndex = 1, + .dlpType = DLP_READ, + .appIDDesc = "test3", + .apiVersion = DEFAULT_API_VERSION + }; + const HapInfoParams infoManagerTestInfoParms3 = { + .userID = 1, + .bundleName = "dlp_test3", + .instIndex = 2, + .dlpType = DLP_FULL_CONTROL, + .appIDDesc = "test3", + .apiVersion = DEFAULT_API_VERSION + }; + GetDlpFlagTest(infoManagerTestInfoParms1, infoManagerTestPolicyPrams, DLP_COMMON); + GetDlpFlagTest(infoManagerTestInfoParms2, infoManagerTestPolicyPrams, DLP_READ); + GetDlpFlagTest(infoManagerTestInfoParms3, infoManagerTestPolicyPrams, DLP_FULL_CONTROL); +} + +/** + * @tc.name: AllocHapToken019 + * @tc.desc: cannot alloc a tokenId with invalid dlpType. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(AllocHapTokenTest, AllocHapToken019, TestSize.Level1) +{ + AccessTokenIDEx tokenIdEx = {0}; + HapPolicyParams infoManagerTestPolicyPrams = { + .apl = APL_NORMAL, + .domain = "test.domain", + .permList = {}, + .permStateList = {} + }; + HapInfoParams infoManagerTestInfoParms1 = { + .userID = 1, + .bundleName = "accesstoken_test", + .instIndex = 4, + .dlpType = INVALID_DLP_TYPE, + .appIDDesc = "test3", + .apiVersion = DEFAULT_API_VERSION + }; + + tokenIdEx = AccessTokenKit::AllocHapToken(infoManagerTestInfoParms1, infoManagerTestPolicyPrams); + ASSERT_EQ(INVALID_TOKENID, tokenIdEx.tokenIdExStruct.tokenID); +} +} // namespace AccessToken +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/accesstoken/test/unittest/src/accesstoken_kit_extension_test.h b/interfaces/innerkits/accesstoken/test/unittest/HapTokenTest/alloc_hap_token_test.h similarity index 65% rename from interfaces/innerkits/accesstoken/test/unittest/src/accesstoken_kit_extension_test.h rename to interfaces/innerkits/accesstoken/test/unittest/HapTokenTest/alloc_hap_token_test.h index 437027c1c158f9ee7e390b5a0a899d425685011a..d24e6118b15929770512d95734359531e1fef008 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/src/accesstoken_kit_extension_test.h +++ b/interfaces/innerkits/accesstoken/test/unittest/HapTokenTest/alloc_hap_token_test.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023 Huawei Device Co., Ltd. + * Copyright (c) 2025 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 @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef ACCESSTOKEN_KIT_EXTENSION_TEST_H -#define ACCESSTOKEN_KIT_EXTENSION_TEST_H +#ifndef ALLOC_HAP_TOKEN_TEST_H +#define ALLOC_HAP_TOKEN_TEST_H #include @@ -26,19 +26,18 @@ namespace OHOS { namespace Security { namespace AccessToken { -class AccessTokenKitExtensionTest : public testing::Test { +class AllocHapTokenTest : public testing::Test { public: static void SetUpTestCase(); static void TearDownTestCase(); void SetUp(); void TearDown(); - unsigned int GetAccessTokenID(int userID, std::string bundleName, int instIndex); - void AllocHapToken(std::vector& permissionDefs, - std::vector& permissionStateFulls, int32_t apiVersion); - - uint64_t selfTokenId_; + unsigned int GetAccessTokenID(int userID, const std::string& bundleName, int instIndex); + void DeleteTestToken() const; + AccessTokenID AllocTestToken(const HapInfoParams& hapInfo, const HapPolicyParams& hapPolicy) const; + void GetDlpFlagTest(const HapInfoParams& info, const HapPolicyParams& policy, int flag); }; } // namespace AccessToken } // namespace Security } // namespace OHOS -#endif // ACCESSTOKEN_KIT_EXTENSION_TEST_H +#endif // ALLOC_HAP_TOKEN_TEST_H \ No newline at end of file diff --git a/interfaces/innerkits/accesstoken/test/unittest/src/app_installation_optimized_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/HapTokenTest/app_installation_optimized_test.cpp similarity index 89% rename from interfaces/innerkits/accesstoken/test/unittest/src/app_installation_optimized_test.cpp rename to interfaces/innerkits/accesstoken/test/unittest/HapTokenTest/app_installation_optimized_test.cpp index 0ac9e0504df4f8d2db13218ec4acf1929e1eb15c..a53385c714c6b50f9d82072d56f401bbf38a961c 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/src/app_installation_optimized_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/HapTokenTest/app_installation_optimized_test.cpp @@ -23,6 +23,7 @@ #include "permission_grant_info.h" #include "permission_state_change_info_parcel.h" #include "string_ex.h" +#include "test_common.h" #include "tokenid_kit.h" #include "token_setproc.h" @@ -31,37 +32,14 @@ namespace OHOS { namespace Security { namespace AccessToken { namespace { -const std::string MANAGE_HAP_TOKENID_PERMISSION = "ohos.permission.MANAGE_HAP_TOKENID"; const std::string CERT_PERMISSION = "ohos.permission.ACCESS_CERT_MANAGER"; const std::string CALENDAR_PERMISSION = "ohos.permission.WRITE_CALENDAR"; const std::string APP_TRACKING_PERMISSION = "ohos.permission.APP_TRACKING_CONSENT"; const std::string ACCESS_BLUETOOTH_PERMISSION = "ohos.permission.ACCESS_BLUETOOTH"; static constexpr int32_t DEFAULT_API_VERSION = 8; static constexpr int32_t MAX_PERM_LIST_SIZE = 1024; +static MockNativeToken* g_mock; -PermissionStateFull g_tddPermReq = { - .permissionName = MANAGE_HAP_TOKENID_PERMISSION, - .isGeneral = true, - .resDeviceID = {"device3"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED} -}; - -PermissionStateFull g_tddPermGrant = { - .permissionName = "ohos.permission.GRANT_SENSITIVE_PERMISSIONS", - .isGeneral = true, - .resDeviceID = {"device3"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED} -}; - -PermissionStateFull g_tddPermRevoke = { - .permissionName = "ohos.permission.REVOKE_SENSITIVE_PERMISSIONS", - .isGeneral = true, - .resDeviceID = {"device3"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED} -}; PermissionStateFull g_infoManagerCameraState = { .permissionName = APP_TRACKING_PERMISSION, .isGeneral = true, @@ -110,21 +88,6 @@ PermissionStateFull g_infoManagerTestStateMdm = { .grantFlags = {0} }; -HapInfoParams g_tddHapInfoParams = { - .userID = 1, - .bundleName = "AppInstallationOptimizedTest", - .instIndex = 0, - .appIDDesc = "test2", - .apiVersion = 11, // api version is 11 - .isSystemApp = true -}; - -HapPolicyParams g_tddPolicyParams = { - .apl = APL_NORMAL, - .domain = "test.domain2", - .permStateList = {g_tddPermReq, g_tddPermGrant, g_tddPermRevoke} -}; - HapInfoParams g_testHapInfoParams = { .userID = 1, .bundleName = "testName", @@ -148,26 +111,26 @@ uint64_t g_selfShellTokenId; void AppInstallationOptimizedTest::SetUpTestCase() { g_selfShellTokenId = GetSelfTokenID(); - // clean up test cases - AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_tddHapInfoParams.userID, - g_tddHapInfoParams.bundleName, - g_tddHapInfoParams.instIndex); - AccessTokenKit::DeleteToken(tokenId); - - tokenId = AccessTokenKit::GetHapTokenID(g_testHapInfoParams.userID, - g_testHapInfoParams.bundleName, - g_testHapInfoParams.instIndex); - AccessTokenKit::DeleteToken(tokenId); - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_tddHapInfoParams, g_tddPolicyParams); - SetSelfTokenID(tokenIdEx.tokenIDEx); + TestCommon::SetTestEvironment(g_selfShellTokenId); + g_mock = new (std::nothrow) MockNativeToken("foundation"); + + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle( + g_testHapInfoParams.userID, g_testHapInfoParams.bundleName, g_testHapInfoParams.instIndex); + AccessTokenKit::DeleteToken(tokenIdEx.tokenIdExStruct.tokenID); } void AppInstallationOptimizedTest::TearDownTestCase() { - AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_tddHapInfoParams.userID, - g_tddHapInfoParams.bundleName, - g_tddHapInfoParams.instIndex); - AccessTokenKit::DeleteToken(tokenId); + if (g_mock != nullptr) { + delete g_mock; + g_mock = nullptr; + } + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle( + g_testHapInfoParams.userID, g_testHapInfoParams.bundleName, g_testHapInfoParams.instIndex); + AccessTokenKit::DeleteToken(tokenIdEx.tokenIdExStruct.tokenID); + + EXPECT_EQ(0, SetSelfTokenID(g_selfShellTokenId)); + TestCommon::ResetTestEvironment(); } void AppInstallationOptimizedTest::SetUp() @@ -189,7 +152,6 @@ HWTEST_F(AppInstallationOptimizedTest, InitHapToken001, TestSize.Level1) { AccessTokenIDEx fullTokenId; int32_t ret = AccessTokenKit::InitHapToken(g_testHapInfoParams, g_testPolicyParams, fullTokenId); - GTEST_LOG_(INFO) << "tokenID :" << fullTokenId.tokenIdExStruct.tokenID; EXPECT_EQ(RET_SUCCESS, ret); ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(fullTokenId.tokenIdExStruct.tokenID)); ASSERT_NE(RET_SUCCESS, AccessTokenKit::DeleteToken(fullTokenId.tokenIdExStruct.tokenID)); @@ -216,7 +178,7 @@ HWTEST_F(AppInstallationOptimizedTest, InitHapToken002, TestSize.Level1) fullTokenId.tokenIdExStruct.tokenID, CERT_PERMISSION); EXPECT_EQ(ret, PERMISSION_GRANTED); std::vector permStatList; - res = AccessTokenKit::GetReqPermissions(fullTokenId.tokenIdExStruct.tokenID, permStatList, true); + res = TestCommon::GetReqPermissionsByTest(fullTokenId.tokenIdExStruct.tokenID, permStatList, true); ASSERT_EQ(RET_SUCCESS, res); ASSERT_EQ(static_cast(1), permStatList.size()); ASSERT_EQ(CERT_PERMISSION, permStatList[0].permissionName); @@ -244,8 +206,7 @@ HWTEST_F(AppInstallationOptimizedTest, InitHapToken003, TestSize.Level1) fullTokenId.tokenIdExStruct.tokenID, CALENDAR_PERMISSION); EXPECT_EQ(ret, PERMISSION_DENIED); uint32_t flag; - AccessTokenKit::GetPermissionFlag( - fullTokenId.tokenIdExStruct.tokenID, CALENDAR_PERMISSION, flag); + TestCommon::GetPermissionFlagByTest(fullTokenId.tokenIdExStruct.tokenID, CALENDAR_PERMISSION, flag); EXPECT_EQ(flag, PERMISSION_DEFAULT_FLAG); ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(fullTokenId.tokenIdExStruct.tokenID)); } @@ -275,7 +236,7 @@ HWTEST_F(AppInstallationOptimizedTest, InitHapToken004, TestSize.Level1) fullTokenId.tokenIdExStruct.tokenID, CALENDAR_PERMISSION); EXPECT_EQ(ret, PERMISSION_GRANTED); std::vector permStatList; - res = AccessTokenKit::GetReqPermissions(fullTokenId.tokenIdExStruct.tokenID, permStatList, false); + res = TestCommon::GetReqPermissionsByTest(fullTokenId.tokenIdExStruct.tokenID, permStatList, false); ASSERT_EQ(RET_SUCCESS, res); ASSERT_EQ(static_cast(1), permStatList.size()); ASSERT_EQ(CALENDAR_PERMISSION, permStatList[0].permissionName); @@ -310,7 +271,7 @@ HWTEST_F(AppInstallationOptimizedTest, InitHapToken005, TestSize.Level1) EXPECT_EQ(ret, PERMISSION_GRANTED); std::vector permStatList; - res = AccessTokenKit::GetReqPermissions(fullTokenId.tokenIdExStruct.tokenID, permStatList, false); + res = TestCommon::GetReqPermissionsByTest(fullTokenId.tokenIdExStruct.tokenID, permStatList, false); ASSERT_EQ(RET_SUCCESS, res); ASSERT_EQ(static_cast(1), permStatList.size()); ASSERT_EQ(CALENDAR_PERMISSION, permStatList[0].permissionName); @@ -353,8 +314,8 @@ HWTEST_F(AppInstallationOptimizedTest, InitHapToken007, TestSize.Level1) }; g_testHapInfoParams.appDistributionType = ""; AccessTokenIDEx fullTokenId; - EXPECT_EQ(ERR_PERM_REQUEST_CFG_FAILED, AccessTokenKit::InitHapToken( - g_testHapInfoParams, testPolicyParam, fullTokenId)); + int32_t res = AccessTokenKit::InitHapToken(g_testHapInfoParams, testPolicyParam, fullTokenId); + EXPECT_EQ(ERR_PERM_REQUEST_CFG_FAILED, res); } /** @@ -442,9 +403,9 @@ HWTEST_F(AppInstallationOptimizedTest, InitHapToken011, TestSize.Level1) res = AccessTokenKit::VerifyAccessToken(dlpFullTokenId1.tokenIdExStruct.tokenID, APP_TRACKING_PERMISSION); EXPECT_EQ(res, PERMISSION_DENIED); - (void)AccessTokenKit::GrantPermission( + (void)TestCommon::GrantPermissionByTest( fullTokenId.tokenIdExStruct.tokenID, APP_TRACKING_PERMISSION, PERMISSION_USER_SET); - (void)AccessTokenKit::RevokePermission( + (void)TestCommon::RevokePermissionByTest( fullTokenId.tokenIdExStruct.tokenID, CALENDAR_PERMISSION, PERMISSION_USER_SET); testHapInfoParams1.instIndex++; @@ -457,10 +418,10 @@ HWTEST_F(AppInstallationOptimizedTest, InitHapToken011, TestSize.Level1) EXPECT_EQ(res, PERMISSION_GRANTED); std::vector permStatList1; - res = AccessTokenKit::GetReqPermissions(fullTokenId.tokenIdExStruct.tokenID, permStatList1, false); + res = TestCommon::GetReqPermissionsByTest(fullTokenId.tokenIdExStruct.tokenID, permStatList1, false); ASSERT_EQ(RET_SUCCESS, res); std::vector permStatList2; - res = AccessTokenKit::GetReqPermissions(dlpFullTokenId2.tokenIdExStruct.tokenID, permStatList2, false); + res = TestCommon::GetReqPermissionsByTest(dlpFullTokenId2.tokenIdExStruct.tokenID, permStatList2, false); ASSERT_EQ(permStatList2.size(), permStatList1.size()); EXPECT_EQ(APP_TRACKING_PERMISSION, permStatList2[0].permissionName); EXPECT_EQ(permStatList2[0].grantStatus[0], PERMISSION_GRANTED); @@ -495,11 +456,11 @@ HWTEST_F(AppInstallationOptimizedTest, UpdateHapToken001, TestSize.Level1) fullTokenId.tokenIdExStruct.tokenID, CERT_PERMISSION); EXPECT_EQ(PERMISSION_GRANTED, ret); - ret = AccessTokenKit::GrantPermission(fullTokenId.tokenIdExStruct.tokenID, APP_TRACKING_PERMISSION, 0); + ret = TestCommon::GrantPermissionByTest(fullTokenId.tokenIdExStruct.tokenID, APP_TRACKING_PERMISSION, 0); EXPECT_EQ(RET_SUCCESS, ret); ret = AccessTokenKit::VerifyAccessToken(fullTokenId.tokenIdExStruct.tokenID, APP_TRACKING_PERMISSION); EXPECT_EQ(PERMISSION_GRANTED, ret); - ret = AccessTokenKit::GrantPermission( + ret = TestCommon::GrantPermissionByTest( fullTokenId.tokenIdExStruct.tokenID, ACCESS_BLUETOOTH_PERMISSION, PERMISSION_SYSTEM_FIXED); EXPECT_EQ(RET_SUCCESS, ret); ret = AccessTokenKit::VerifyAccessToken( @@ -545,12 +506,12 @@ HWTEST_F(AppInstallationOptimizedTest, UpdateHapToken002, TestSize.Level1) AccessTokenIDEx fullTokenId; int32_t ret = AccessTokenKit::InitHapToken(g_testHapInfoParams, testPolicyParams1, fullTokenId); EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::RevokePermission( + ret = TestCommon::RevokePermissionByTest( fullTokenId.tokenIdExStruct.tokenID, APP_TRACKING_PERMISSION, PERMISSION_USER_FIXED); EXPECT_EQ(RET_SUCCESS, ret); std::vector permStatList; - int32_t res = AccessTokenKit::GetReqPermissions(fullTokenId.tokenIdExStruct.tokenID, permStatList, false); + int32_t res = TestCommon::GetReqPermissionsByTest(fullTokenId.tokenIdExStruct.tokenID, permStatList, false); ASSERT_EQ(RET_SUCCESS, res); ASSERT_EQ(static_cast(1), permStatList.size()); ASSERT_EQ(APP_TRACKING_PERMISSION, permStatList[0].permissionName); @@ -569,7 +530,7 @@ HWTEST_F(AppInstallationOptimizedTest, UpdateHapToken002, TestSize.Level1) ret = AccessTokenKit::UpdateHapToken(fullTokenId, info, testPolicyParams2); ASSERT_EQ(RET_SUCCESS, ret); std::vector permStatList1; - res = AccessTokenKit::GetReqPermissions(fullTokenId.tokenIdExStruct.tokenID, permStatList1, false); + res = TestCommon::GetReqPermissionsByTest(fullTokenId.tokenIdExStruct.tokenID, permStatList1, false); ASSERT_EQ(RET_SUCCESS, res); ASSERT_EQ(static_cast(2), permStatList1.size()); ASSERT_EQ(APP_TRACKING_PERMISSION, permStatList1[0].permissionName); @@ -620,7 +581,7 @@ HWTEST_F(AppInstallationOptimizedTest, UpdateHapToken003, TestSize.Level1) ret = AccessTokenKit::UpdateHapToken(fullTokenId, info, testPolicyParams2); ASSERT_EQ(RET_SUCCESS, ret); std::vector permStatList1; - int32_t res = AccessTokenKit::GetReqPermissions(fullTokenId.tokenIdExStruct.tokenID, permStatList1, false); + int32_t res = TestCommon::GetReqPermissionsByTest(fullTokenId.tokenIdExStruct.tokenID, permStatList1, false); ASSERT_EQ(RET_SUCCESS, res); ASSERT_EQ(static_cast(2), permStatList1.size()); ASSERT_EQ(APP_TRACKING_PERMISSION, permStatList1[0].permissionName); @@ -668,7 +629,7 @@ HWTEST_F(AppInstallationOptimizedTest, UpdateHapToken004, TestSize.Level1) ret = AccessTokenKit::UpdateHapToken(fullTokenId, info, testPolicyParams2); ASSERT_EQ(RET_SUCCESS, ret); std::vector state; - int32_t res = AccessTokenKit::GetReqPermissions(fullTokenId.tokenIdExStruct.tokenID, state, false); + int32_t res = TestCommon::GetReqPermissionsByTest(fullTokenId.tokenIdExStruct.tokenID, state, false); ASSERT_EQ(RET_SUCCESS, res); ASSERT_EQ(static_cast(2), state.size()); ASSERT_EQ(CALENDAR_PERMISSION, state[1].permissionName); @@ -725,7 +686,8 @@ HWTEST_F(AppInstallationOptimizedTest, UpdateHapToken006, TestSize.Level1) .permStateList = {g_infoManagerCameraState} }; AccessTokenIDEx fullTokenId; - EXPECT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(g_testHapInfoParams, testPolicyParam, fullTokenId)); + int32_t res = AccessTokenKit::InitHapToken(g_testHapInfoParams, testPolicyParam, fullTokenId); + EXPECT_EQ(RET_SUCCESS, res); HapPolicyParams testPolicyParam2 = { .apl = APL_SYSTEM_BASIC, @@ -738,7 +700,8 @@ HWTEST_F(AppInstallationOptimizedTest, UpdateHapToken006, TestSize.Level1) .isSystemApp = false }; info.appDistributionType = ""; - EXPECT_EQ(ERR_PERM_REQUEST_CFG_FAILED, AccessTokenKit::UpdateHapToken(fullTokenId, info, testPolicyParam2)); + res = AccessTokenKit::UpdateHapToken(fullTokenId, info, testPolicyParam2); + EXPECT_EQ(ERR_PERM_REQUEST_CFG_FAILED, res); ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(fullTokenId.tokenIdExStruct.tokenID)); } @@ -874,7 +837,7 @@ HWTEST_F(AppInstallationOptimizedTest, UpdateHapToken010, TestSize.Level1) ret = AccessTokenKit::UpdateHapToken(fullTokenId, info, testPolicyParams2); ASSERT_EQ(RET_SUCCESS, ret); std::vector state; - int32_t res = AccessTokenKit::GetReqPermissions(fullTokenId.tokenIdExStruct.tokenID, state, false); + int32_t res = TestCommon::GetReqPermissionsByTest(fullTokenId.tokenIdExStruct.tokenID, state, false); ASSERT_EQ(RET_SUCCESS, res); ASSERT_EQ(static_cast(1), state.size()); ASSERT_EQ(APP_TRACKING_PERMISSION, state[0].permissionName); @@ -919,7 +882,7 @@ HWTEST_F(AppInstallationOptimizedTest, UpdateHapToken011, TestSize.Level1) ret = AccessTokenKit::UpdateHapToken(fullTokenId, info, testPolicyParams2); ASSERT_EQ(RET_SUCCESS, ret); std::vector state; - int32_t res = AccessTokenKit::GetReqPermissions(fullTokenId.tokenIdExStruct.tokenID, state, false); + int32_t res = TestCommon::GetReqPermissionsByTest(fullTokenId.tokenIdExStruct.tokenID, state, false); ASSERT_EQ(RET_SUCCESS, res); ASSERT_EQ(static_cast(1), state.size()); ASSERT_EQ(APP_TRACKING_PERMISSION, state[0].permissionName); @@ -946,10 +909,10 @@ HWTEST_F(AppInstallationOptimizedTest, UpdateHapToken012, TestSize.Level1) int32_t ret = AccessTokenKit::InitHapToken(g_testHapInfoParams, testPolicyParams1, fullTokenId); EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::GrantPermission( + ret = TestCommon::GrantPermissionByTest( fullTokenId.tokenIdExStruct.tokenID, APP_TRACKING_PERMISSION, PERMISSION_USER_FIXED); EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::RevokePermission( + ret = TestCommon::RevokePermissionByTest( fullTokenId.tokenIdExStruct.tokenID, CALENDAR_PERMISSION, PERMISSION_USER_FIXED); EXPECT_EQ(RET_SUCCESS, ret); @@ -974,7 +937,7 @@ HWTEST_F(AppInstallationOptimizedTest, UpdateHapToken012, TestSize.Level1) ret = AccessTokenKit::UpdateHapToken(fullTokenId, info, testPolicyParams2); ASSERT_EQ(RET_SUCCESS, ret); std::vector state; - AccessTokenKit::GetReqPermissions(fullTokenId.tokenIdExStruct.tokenID, state, false); + TestCommon::GetReqPermissionsByTest(fullTokenId.tokenIdExStruct.tokenID, state, false); ASSERT_EQ(static_cast(2), state.size()); ASSERT_EQ(APP_TRACKING_PERMISSION, state[0].permissionName); EXPECT_EQ(state[0].grantStatus[0], PERMISSION_GRANTED); @@ -1014,10 +977,10 @@ HWTEST_F(AppInstallationOptimizedTest, UpdateHapToken013, TestSize.Level1) int32_t ret = AccessTokenKit::InitHapToken(g_testHapInfoParams, testPolicyParams1, fullTokenId); EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::GrantPermission( + ret = TestCommon::GrantPermissionByTest( fullTokenId.tokenIdExStruct.tokenID, APP_TRACKING_PERMISSION, PERMISSION_USER_FIXED); EXPECT_NE(RET_SUCCESS, ret); - ret = AccessTokenKit::RevokePermission( + ret = TestCommon::RevokePermissionByTest( fullTokenId.tokenIdExStruct.tokenID, CALENDAR_PERMISSION, PERMISSION_USER_FIXED); EXPECT_NE(RET_SUCCESS, ret); @@ -1031,7 +994,7 @@ HWTEST_F(AppInstallationOptimizedTest, UpdateHapToken013, TestSize.Level1) ret = AccessTokenKit::UpdateHapToken(fullTokenId, info, testPolicyParams1); ASSERT_EQ(RET_SUCCESS, ret); std::vector state; - AccessTokenKit::GetReqPermissions(fullTokenId.tokenIdExStruct.tokenID, state, false); + TestCommon::GetReqPermissionsByTest(fullTokenId.tokenIdExStruct.tokenID, state, false); ASSERT_EQ(static_cast(2), state.size()); EXPECT_EQ(state[0].grantStatus[0], PERMISSION_GRANTED); EXPECT_EQ(state[0].grantFlags[0], PERMISSION_GRANTED_BY_POLICY); @@ -1068,7 +1031,7 @@ HWTEST_F(AppInstallationOptimizedTest, UpdateHapToken014, TestSize.Level1) int32_t ret = AccessTokenKit::InitHapToken(g_testHapInfoParams, testPolicyParams1, fullTokenId); EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::RevokePermission( + ret = TestCommon::RevokePermissionByTest( fullTokenId.tokenIdExStruct.tokenID, CALENDAR_PERMISSION, PERMISSION_USER_FIXED); EXPECT_EQ(RET_SUCCESS, ret); @@ -1082,7 +1045,7 @@ HWTEST_F(AppInstallationOptimizedTest, UpdateHapToken014, TestSize.Level1) ret = AccessTokenKit::UpdateHapToken(fullTokenId, info, testPolicyParams1); ASSERT_EQ(RET_SUCCESS, ret); std::vector state; - AccessTokenKit::GetReqPermissions(fullTokenId.tokenIdExStruct.tokenID, state, false); + TestCommon::GetReqPermissionsByTest(fullTokenId.tokenIdExStruct.tokenID, state, false); ASSERT_EQ(static_cast(2), state.size()); EXPECT_EQ(state[0].grantStatus[0], PERMISSION_GRANTED); EXPECT_EQ(state[0].grantFlags[0], PERMISSION_SYSTEM_FIXED); @@ -1171,19 +1134,19 @@ HWTEST_F(AppInstallationOptimizedTest, InitHapTokenAbnormal003, TestSize.Level1) testHapInfoParams.userID = -1; AccessTokenIDEx fullTokenId; int32_t res = AccessTokenKit::InitHapToken(testHapInfoParams, testPolicyParam, fullTokenId); - EXPECT_NE(RET_SUCCESS, res); + EXPECT_EQ(ERR_PARAM_INVALID, res); testHapInfoParams.userID = g_testHapInfoParams.userID; // invalid bundleName testHapInfoParams.bundleName = ""; res = AccessTokenKit::InitHapToken(testHapInfoParams, testPolicyParam, fullTokenId); - EXPECT_NE(RET_SUCCESS, res); + EXPECT_EQ(ERR_PARAM_INVALID, res); testHapInfoParams.bundleName = g_testHapInfoParams.bundleName; // invalid dlpType testHapInfoParams.dlpType = -1; res = AccessTokenKit::InitHapToken(testHapInfoParams, testPolicyParam, fullTokenId); - EXPECT_NE(RET_SUCCESS, res); + EXPECT_EQ(ERR_PARAM_INVALID, res); testHapInfoParams.dlpType = g_testHapInfoParams.dlpType; int32_t invalidAppIdLen = 10241; // 10241 is invalid appid length @@ -1191,7 +1154,7 @@ HWTEST_F(AppInstallationOptimizedTest, InitHapTokenAbnormal003, TestSize.Level1) std::string invalidAppIDDesc (invalidAppIdLen, 'x'); testHapInfoParams.appIDDesc = invalidAppIDDesc; res = AccessTokenKit::InitHapToken(testHapInfoParams, testPolicyParam, fullTokenId); - EXPECT_NE(RET_SUCCESS, res); + EXPECT_EQ(ERR_PARAM_INVALID, res); testHapInfoParams.appIDDesc = g_testHapInfoParams.appIDDesc; } diff --git a/interfaces/innerkits/accesstoken/test/unittest/src/app_installation_optimized_test.h b/interfaces/innerkits/accesstoken/test/unittest/HapTokenTest/app_installation_optimized_test.h similarity index 97% rename from interfaces/innerkits/accesstoken/test/unittest/src/app_installation_optimized_test.h rename to interfaces/innerkits/accesstoken/test/unittest/HapTokenTest/app_installation_optimized_test.h index 7806d97b8d3ed9d04031069bf4dd743cc0996bca..58e2f51c844f2d64886f28d8c6e8970c5107ed5f 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/src/app_installation_optimized_test.h +++ b/interfaces/innerkits/accesstoken/test/unittest/HapTokenTest/app_installation_optimized_test.h @@ -32,7 +32,6 @@ public: static void TearDownTestCase(); void SetUp(); void TearDown(); - uint64_t selfTokenId_; }; } // namespace AccessToken } // namespace Security diff --git a/interfaces/innerkits/accesstoken/test/unittest/HapTokenTest/delete_token_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/HapTokenTest/delete_token_test.cpp index e0be46f11940f3edb40c633c1ba0e12e2c8ece47..68281ff829b04ca035ab8b28a46fce806b700fd4 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/HapTokenTest/delete_token_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/HapTokenTest/delete_token_test.cpp @@ -34,31 +34,40 @@ namespace OHOS { namespace Security { namespace AccessToken { namespace { -static AccessTokenID g_selfTokenId = 0; +static uint64_t g_selfTokenId = 0; static const std::string TEST_BUNDLE_NAME = "ohos"; static const unsigned int TEST_TOKENID_INVALID = 0; static const int TEST_USER_ID = 0; static constexpr int32_t DEFAULT_API_VERSION = 8; -HapInfoParams g_infoManagerTestInfoParms = TestCommon::GetInfoManagerTestInfoParms(); -HapPolicyParams g_infoManagerTestPolicyPrams = TestCommon::GetInfoManagerTestPolicyPrams(); +static const std::string TEST_PERMISSION = "ohos.permission.ALPHA"; +static MockNativeToken* g_mock; + +HapInfoParams g_infoParms = { + .userID = 1, + .bundleName = "GetHapTokenInfoFromRemoteTest", + .instIndex = 0, + .appIDDesc = "test.bundle", + .apiVersion = 8, + .appDistributionType = "enterprise_mdm" }; +HapPolicyParams g_policyPrams = { + .apl = APL_NORMAL, + .domain = "test.domain", +}; +} + void DeleteTokenTest::SetUpTestCase() { g_selfTokenId = GetSelfTokenID(); + TestCommon::SetTestEvironment(g_selfTokenId); + + // native process with MANAGER_HAP_ID + g_mock = new (std::nothrow) MockNativeToken("foundation"); // clean up test cases AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, - TestCommon::GetTestPolicyParams()); - SetSelfTokenID(tokenIdEx.tokenIDEx); } void DeleteTokenTest::TearDownTestCase() @@ -66,19 +75,17 @@ void DeleteTokenTest::TearDownTestCase() AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); AccessTokenKit::DeleteToken(tokenID); - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - SetSelfTokenID(g_selfTokenId); + if (g_mock != nullptr) { + delete g_mock; + g_mock = nullptr; + } + EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId)); + TestCommon::ResetTestEvironment(); } void DeleteTokenTest::SetUp() { LOGI(ATM_DOMAIN, ATM_TAG, "SetUp ok."); - - setuid(0); HapInfoParams info = { .userID = TEST_USER_ID, .bundleName = TEST_BUNDLE_NAME, @@ -91,14 +98,25 @@ void DeleteTokenTest::SetUp() .apl = APL_NORMAL, .domain = "domain" }; - TestCommon::TestPreparePermDefList(policy); + PermissionDef permissionDefAlpha = { + .permissionName = TEST_PERMISSION, + .bundleName = TEST_BUNDLE_NAME, + .grantMode = GrantMode::USER_GRANT, + .availableLevel = APL_NORMAL, + .provisionEnable = false, + .distributedSceneEnable = false + }; + policy.permList.emplace_back(permissionDefAlpha); TestCommon::TestPreparePermStateList(policy); - - AccessTokenKit::AllocHapToken(info, policy); + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(info, policy, tokenIdEx)); + ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIdExStruct.tokenID); } void DeleteTokenTest::TearDown() { + AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenKit::DeleteToken(tokenID); } /** @@ -172,12 +190,9 @@ HWTEST_F(DeleteTokenTest, DeleteTokenAbnormalTest001, TestSize.Level1) HWTEST_F(DeleteTokenTest, DeleteTokenAbnormalTest002, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "DeleteTokenAbnormalTest002"); - + AccessTokenID tokenID = GetSelfTokenID(); // native token // tokenID != TOKEN_HAP - AccessTokenID tokenID = AccessTokenKit::GetNativeTokenId("hdcd"); - ASSERT_EQ(TOKEN_SHELL, AccessTokenKit::GetTokenType(tokenID)); - int ret = AccessTokenKit::DeleteToken(tokenID); - ASSERT_EQ(ERR_PARAM_INVALID, ret); + ASSERT_EQ(ERR_PARAM_INVALID, AccessTokenKit::DeleteToken(tokenID)); } /** @@ -190,7 +205,9 @@ HWTEST_F(DeleteTokenTest, DeleteTokenSpecTest001, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "DeleteTokenSpecTest001"); - AccessTokenID tokenID = TestCommon::AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(g_infoParms, g_policyPrams, tokenIdEx)); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; ASSERT_NE(INVALID_TOKENID, tokenID); ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); diff --git a/interfaces/innerkits/accesstoken/test/unittest/HapTokenTest/get_hap_token_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/HapTokenTest/get_hap_token_test.cpp index ef9162c90c00fc7c3b2c9263064ef048b63fcaa7..91c471ad1e13840c38ceb54f42a34cfd0ef7f8c1 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/HapTokenTest/get_hap_token_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/HapTokenTest/get_hap_token_test.cpp @@ -33,44 +33,38 @@ namespace OHOS { namespace Security { namespace AccessToken { namespace { -static AccessTokenID g_selfTokenId = 0; +static uint64_t g_selfTokenId = 0; static const std::string TEST_BUNDLE_NAME = "ohos"; static const unsigned int TEST_TOKENID_INVALID = 0; static const int TEST_USER_ID = 0; static constexpr int32_t DEFAULT_API_VERSION = 8; static const int TEST_USER_ID_INVALID = -1; +static MockNativeToken* g_mock; HapInfoParams g_infoManagerTestSystemInfoParms = TestCommon::GetInfoManagerTestSystemInfoParms(); +HapInfoParams g_infoManagerTestNormalInfoParms = TestCommon::GetInfoManagerTestNormalInfoParms(); HapPolicyParams g_infoManagerTestPolicyPrams = TestCommon::GetInfoManagerTestPolicyPrams(); } void GetHapTokenTest::SetUpTestCase() { g_selfTokenId = GetSelfTokenID(); + TestCommon::SetTestEvironment(g_selfTokenId); + g_mock = new (std::nothrow) MockNativeToken("foundation"); // clean up test cases AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestSystemInfoParms.userID, - g_infoManagerTestSystemInfoParms.bundleName, - g_infoManagerTestSystemInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestSystemInfoParms, - TestCommon::GetTestPolicyParams()); - SetSelfTokenID(tokenIdEx.tokenIDEx); + TestCommon::DeleteTestHapToken(tokenID); } void GetHapTokenTest::TearDownTestCase() { AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestSystemInfoParms.userID, - g_infoManagerTestSystemInfoParms.bundleName, - g_infoManagerTestSystemInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); + TestCommon::DeleteTestHapToken(tokenID); + if (g_mock != nullptr) { + delete g_mock; + g_mock = nullptr; + } SetSelfTokenID(g_selfTokenId); } @@ -78,7 +72,6 @@ void GetHapTokenTest::SetUp() { LOGI(ATM_DOMAIN, ATM_TAG, "SetUp ok."); - setuid(0); HapInfoParams info = { .userID = TEST_USER_ID, .bundleName = TEST_BUNDLE_NAME, @@ -91,14 +84,17 @@ void GetHapTokenTest::SetUp() .apl = APL_NORMAL, .domain = "domain" }; - TestCommon::TestPreparePermDefList(policy); TestCommon::TestPreparePermStateList(policy); - AccessTokenKit::AllocHapToken(info, policy); + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(info, policy, tokenIdEx)); + ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIdExStruct.tokenID); } void GetHapTokenTest::TearDown() { + AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + TestCommon::DeleteTestHapToken(tokenID); } /** @@ -119,7 +115,7 @@ HWTEST_F(GetHapTokenTest, GetHapTokenIDFuncTest001, TestSize.Level1) ASSERT_EQ(RET_SUCCESS, ret); ASSERT_EQ(hapTokenInfoRes.bundleName, TEST_BUNDLE_NAME); - ret = AccessTokenKit::DeleteToken(tokenID); + ret = TestCommon::DeleteTestHapToken(tokenID); ASSERT_EQ(RET_SUCCESS, ret); } @@ -147,13 +143,16 @@ HWTEST_F(GetHapTokenTest, GetHapTokenIDAbnormalTest002, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "GetHapTokenIDAbnormalTest002"); - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, "invalid bundlename", 0); + AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, "", 0); + ASSERT_EQ(INVALID_TOKENID, tokenID); + + tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, "invalid bundlename", 0); ASSERT_EQ(INVALID_TOKENID, tokenID); } /** * @tc.name: GetHapTokenIDAbnormalTest003 - * @tc.desc: cannot get hap tokenid with invalid bundlename. + * @tc.desc: cannot get hap tokenid with invalid instIndex. * @tc.type: FUNC * @tc.require: Issue Number */ @@ -175,10 +174,9 @@ HWTEST_F(GetHapTokenTest, GetHapTokenIDExFuncTest001, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "GetHapTokenIDExFuncTest001"); - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestSystemInfoParms, - g_infoManagerTestPolicyPrams); - - AccessTokenIDEx tokenIdEx1 = AccessTokenKit::GetHapTokenIDEx(g_infoManagerTestSystemInfoParms.userID, + AccessTokenIDEx tokenIdEx; + TestCommon::AllocTestHapToken(g_infoManagerTestSystemInfoParms, g_infoManagerTestPolicyPrams, tokenIdEx); + AccessTokenIDEx tokenIdEx1 = TestCommon::GetHapTokenIdFromBundle(g_infoManagerTestSystemInfoParms.userID, g_infoManagerTestSystemInfoParms.bundleName, g_infoManagerTestSystemInfoParms.instIndex); @@ -188,7 +186,7 @@ HWTEST_F(GetHapTokenTest, GetHapTokenIDExFuncTest001, TestSize.Level1) int ret = AccessTokenKit::GetHapTokenInfo(tokenID, hapTokenInfoRes); ASSERT_EQ(RET_SUCCESS, ret); ASSERT_EQ(hapTokenInfoRes.bundleName, g_infoManagerTestSystemInfoParms.bundleName); - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -229,7 +227,10 @@ HWTEST_F(GetHapTokenTest, GetHapTokenIDExAbnormalTest003, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "GetHapTokenIDExAbnormalTest003"); - AccessTokenIDEx tokenIdEx = AccessTokenKit::GetHapTokenIDEx(TEST_USER_ID, TEST_BUNDLE_NAME, 0xffff); + AccessTokenIDEx tokenIdEx = AccessTokenKit::GetHapTokenIDEx(TEST_USER_ID, "", 0); + ASSERT_EQ(INVALID_TOKENID, tokenIdEx.tokenIDEx); + + tokenIdEx = AccessTokenKit::GetHapTokenIDEx(TEST_USER_ID, TEST_BUNDLE_NAME, 0xffff); ASSERT_EQ(INVALID_TOKENID, tokenIdEx.tokenIDEx); } @@ -256,7 +257,7 @@ HWTEST_F(GetHapTokenTest, GetHapTokenInfoFuncTest001, TestSize.Level0) ASSERT_EQ(hapTokenInfoRes.instIndex, 0); ASSERT_EQ(hapTokenInfoRes.bundleName, TEST_BUNDLE_NAME); - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -295,6 +296,77 @@ HWTEST_F(GetHapTokenTest, GetHapTokenInfoExtensionFuncTest001, TestSize.Level1) ret = AccessTokenKit::GetHapTokenInfoExtension(INVALID_TOKENID, hapTokenInfoExt); ASSERT_EQ(ret, AccessTokenError::ERR_PARAM_INVALID); } + +/** + * @tc.name: IsSystemAppByFullTokenIDTest001 + * @tc.desc: check systemapp level by TokenIDEx after AllocHapToken function set isSystemApp true. + * @tc.type: FUNC + * @tc.require: issueI60F1M + */ +HWTEST_F(GetHapTokenTest, IsSystemAppByFullTokenIDTest001, TestSize.Level1) +{ + std::vector reqPerm; + AccessTokenIDEx tokenIdEx = {0}; + TestCommon::AllocTestHapToken(g_infoManagerTestSystemInfoParms, g_infoManagerTestPolicyPrams, tokenIdEx); + ASSERT_EQ(true, TokenIdKit::IsSystemAppByFullTokenID(tokenIdEx.tokenIDEx)); + + AccessTokenIDEx tokenIdEx1 = AccessTokenKit::GetHapTokenIDEx(1, "accesstoken_test", 0); + ASSERT_EQ(tokenIdEx.tokenIDEx, tokenIdEx1.tokenIDEx); + + UpdateHapInfoParams info; + info.appIDDesc = g_infoManagerTestSystemInfoParms.appIDDesc; + info.apiVersion = g_infoManagerTestSystemInfoParms.apiVersion; + info.isSystemApp = false; + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UpdateHapToken(tokenIdEx, info, g_infoManagerTestPolicyPrams)); + tokenIdEx1 = AccessTokenKit::GetHapTokenIDEx(1, "accesstoken_test", 0); + ASSERT_EQ(tokenIdEx.tokenIDEx, tokenIdEx1.tokenIDEx); + + ASSERT_EQ(false, TokenIdKit::IsSystemAppByFullTokenID(tokenIdEx.tokenIDEx)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID)); +} + +/** + * @tc.name: IsSystemAppByFullTokenIDTest002 + * @tc.desc: check systemapp level by TokenIDEx after AllocHapToken function set isSystemApp false. + * @tc.type: FUNC + * @tc.require: issueI60F1M + */ +HWTEST_F(GetHapTokenTest, IsSystemAppByFullTokenIDTest002, TestSize.Level1) +{ + AccessTokenIDEx tokenIdEx = {0}; + TestCommon::AllocTestHapToken(g_infoManagerTestSystemInfoParms, g_infoManagerTestPolicyPrams, tokenIdEx); + ASSERT_TRUE(TokenIdKit::IsSystemAppByFullTokenID(tokenIdEx.tokenIDEx)); + + AccessTokenIDEx tokenIdEx1 = AccessTokenKit::GetHapTokenIDEx(1, "accesstoken_test", 0); + ASSERT_EQ(tokenIdEx.tokenIDEx, tokenIdEx1.tokenIDEx); + UpdateHapInfoParams info; + info.appIDDesc = g_infoManagerTestNormalInfoParms.appIDDesc; + info.apiVersion = g_infoManagerTestNormalInfoParms.apiVersion; + info.isSystemApp = true; + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UpdateHapToken(tokenIdEx, info, g_infoManagerTestPolicyPrams)); + tokenIdEx1 = AccessTokenKit::GetHapTokenIDEx(1, "accesstoken_test", 0); + ASSERT_EQ(tokenIdEx.tokenIDEx, tokenIdEx1.tokenIDEx); + + ASSERT_EQ(true, TokenIdKit::IsSystemAppByFullTokenID(tokenIdEx.tokenIDEx)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID)); +} + +/** + * @tc.name: IsSystemAppByFullTokenIDTest003 + * @tc.desc: check systemapp level by TokenIDEx after AllocHapToken function set isSystemApp false. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(GetHapTokenTest, IsSystemAppByFullTokenIDTest003, TestSize.Level1) +{ + AccessTokenIDEx tokenIdEx = {0}; + TestCommon::AllocTestHapToken(g_infoManagerTestSystemInfoParms, g_infoManagerTestPolicyPrams, tokenIdEx); + AccessTokenIDEx tokenIdEx1 = AccessTokenKit::GetHapTokenIDEx(1, "accesstoken_test", 0); + ASSERT_EQ(tokenIdEx.tokenIDEx, tokenIdEx1.tokenIDEx); + bool res = AccessTokenKit::IsSystemAppByFullTokenID(tokenIdEx.tokenIDEx); + ASSERT_TRUE(res); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID)); +} } // namespace AccessToken } // namespace Security } // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/accesstoken/test/unittest/HapTokenTest/get_token_type_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/HapTokenTest/get_token_type_test.cpp index cd7c0dccfbdcae704fb7d50d1abce8238ea39bcf..b6b81fb803aeef015e26cc3a8a59dbd133761114 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/HapTokenTest/get_token_type_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/HapTokenTest/get_token_type_test.cpp @@ -33,43 +33,31 @@ namespace OHOS { namespace Security { namespace AccessToken { namespace { -static AccessTokenID g_selfTokenId = 0; +static uint64_t g_selfTokenId = 0; static const std::string TEST_BUNDLE_NAME = "ohos"; static const int TEST_USER_ID = 0; static constexpr int32_t DEFAULT_API_VERSION = 8; -HapInfoParams g_infoManagerTestInfoParms = TestCommon::GetInfoManagerTestInfoParms(); -HapPolicyParams g_infoManagerTestPolicyPrams = TestCommon::GetInfoManagerTestPolicyPrams(); } void GetTokenTypeTest::SetUpTestCase() { g_selfTokenId = GetSelfTokenID(); + TestCommon::SetTestEvironment(g_selfTokenId); // clean up test cases - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, - TestCommon::GetTestPolicyParams()); - SetSelfTokenID(tokenIdEx.tokenIDEx); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + TestCommon::DeleteTestHapToken(tokenID); } void GetTokenTypeTest::TearDownTestCase() { - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + TestCommon::DeleteTestHapToken(tokenID); SetSelfTokenID(g_selfTokenId); + TestCommon::ResetTestEvironment(); } void GetTokenTypeTest::SetUp() @@ -89,10 +77,11 @@ void GetTokenTypeTest::SetUp() .apl = APL_NORMAL, .domain = "domain" }; - TestCommon::TestPreparePermDefList(policy); TestCommon::TestPreparePermStateList(policy); - AccessTokenKit::AllocHapToken(info, policy); + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ(RET_SUCCESS, TestCommon::AllocTestHapToken(info, policy, tokenIdEx)); + ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIdExStruct.tokenID); } void GetTokenTypeTest::TearDown() @@ -108,28 +97,19 @@ void GetTokenTypeTest::TearDown() HWTEST_F(GetTokenTypeTest, GetTokenTypeFuncTest001, TestSize.Level0) { LOGI(ATM_DOMAIN, ATM_TAG, "GetTokenTypeFuncTest001"); - + MockNativeToken mock("foundation"); // type = TOKEN_SHELL AccessTokenID tokenID = AccessTokenKit::GetNativeTokenId("hdcd"); - int ret = AccessTokenKit::GetTokenType(tokenID); - ASSERT_EQ(TOKEN_SHELL, ret); + ASSERT_NE(INVALID_TOKENID, tokenID); + ASSERT_EQ(TOKEN_SHELL, AccessTokenKit::GetTokenType(tokenID)); // type = TOKEN_NATIVE tokenID = AccessTokenKit::GetNativeTokenId("foundation"); - ret = AccessTokenKit::GetTokenType(tokenID); - ASSERT_EQ(TOKEN_NATIVE, ret); + ASSERT_EQ(TOKEN_NATIVE, AccessTokenKit::GetTokenType(tokenID)); // type = TOKEN_HAP - tokenID = TestCommon::AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); - ret = AccessTokenKit::GetTokenType(tokenID); - ASSERT_EQ(TOKEN_HAP, ret); - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); - ret = AccessTokenKit::DeleteToken(tokenID); - if (tokenID != 0) { - ASSERT_EQ(RET_SUCCESS, ret); - } + tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + ASSERT_EQ(TOKEN_HAP, AccessTokenKit::GetTokenType(tokenID)); } /** @@ -143,8 +123,7 @@ HWTEST_F(GetTokenTypeTest, GetTokenTypeAbnormalTest001, TestSize.Level0) LOGI(ATM_DOMAIN, ATM_TAG, "GetTokenTypeAbnormalTest001"); AccessTokenID tokenID = 0; - int32_t ret = AccessTokenKit::GetTokenType(tokenID); - ASSERT_EQ(TOKEN_INVALID, ret); + ASSERT_EQ(TOKEN_INVALID, AccessTokenKit::GetTokenType(tokenID)); } /** @@ -188,25 +167,6 @@ HWTEST_F(GetTokenTypeTest, GetTokenTypeFlagFuncTest001, TestSize.Level1) ATokenTypeEnum ret = AccessTokenKit::GetTokenTypeFlag(tokenID); ASSERT_EQ(ret, TOKEN_NATIVE); } - -/** - * @tc.name: GetTokenTypeFlagFuncTest002 - * @tc.desc: Get token type with hap tokenID. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(GetTokenTypeTest, GetTokenTypeFlagFuncTest002, TestSize.Level1) -{ - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIdExStruct.tokenID); - - ATokenTypeEnum ret = AccessTokenKit::GetTokenTypeFlag(tokenIdEx.tokenIdExStruct.tokenID); - ASSERT_EQ(ret, TOKEN_HAP); - - int res = AccessTokenKit::DeleteToken(tokenIdEx.tokenIdExStruct.tokenID); - ASSERT_EQ(RET_SUCCESS, res); -} } // namespace AccessToken } // namespace Security } // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/accesstoken/test/unittest/HapTokenTest/init_hap_token_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/HapTokenTest/init_hap_token_test.cpp index 4a9b2fde2e24307b70af01852cc81aeb5359aad7..6d8e0e68caffe143074f3e0d137cb50d3df16870 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/HapTokenTest/init_hap_token_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/HapTokenTest/init_hap_token_test.cpp @@ -34,7 +34,7 @@ namespace OHOS { namespace Security { namespace AccessToken { namespace { -static AccessTokenID g_selfTokenId = 0; +static uint64_t g_selfTokenId = 0; static constexpr int32_t THIRTY_TIME_CYCLES = 30; static constexpr int32_t MAX_EXTENDED_MAP_SIZE = 512; static constexpr int32_t MAX_VALUE_LENGTH = 1024; @@ -84,45 +84,42 @@ HapInfoParams g_testHapInfoParams = { .instIndex = 0, .appIDDesc = "InitHapTokenTest", .apiVersion = TestCommon::DEFAULT_API_VERSION, - .isSystemApp = true, + .isSystemApp = false, .appDistributionType = "" }; HapPolicyParams g_testPolicyParams = { .apl = APL_SYSTEM_CORE, .domain = "test_domain", - .permList = {}, .permStateList = { g_infoManagerManageHapState }, .aclRequestedList = {}, .preAuthorizationInfo = {} }; +static MockNativeToken* g_mock; }; void InitHapTokenTest::SetUpTestCase() { g_selfTokenId = GetSelfTokenID(); - // clean up test cases - AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_testHapInfoParams.userID, - g_testHapInfoParams.bundleName, - g_testHapInfoParams.instIndex); - AccessTokenKit::DeleteToken(tokenId); - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_testHapInfoParams, g_testPolicyParams); - SetSelfTokenID(tokenIdEx.tokenIDEx); + TestCommon::SetTestEvironment(g_selfTokenId); + + // native process with MANAGER_HAP_ID + g_mock = new (std::nothrow) MockNativeToken("foundation"); } void InitHapTokenTest::TearDownTestCase() { - AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_testHapInfoParams.userID, - g_testHapInfoParams.bundleName, - g_testHapInfoParams.instIndex); - AccessTokenKit::DeleteToken(tokenId); - SetSelfTokenID(g_selfTokenId); + if (g_mock != nullptr) { + delete g_mock; + g_mock = nullptr; + } + EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId)); + TestCommon::ResetTestEvironment(); } void InitHapTokenTest::SetUp() { LOGI(ATM_DOMAIN, ATM_TAG, "SetUp ok."); - setuid(0); } void InitHapTokenTest::TearDown() @@ -138,28 +135,30 @@ void InitHapTokenTest::TearDown() HWTEST_F(InitHapTokenTest, InitHapTokenFuncTest001, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "InitHapTokenFuncTest001"); + MockNativeToken mock("foundation"); HapInfoParams infoParams; HapPolicyParams policyParams; TestCommon::GetHapParams(infoParams, policyParams); infoParams.isSystemApp = false; AccessTokenIDEx fullTokenId; - int32_t ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId)); AccessTokenID tokenID = fullTokenId.tokenIdExStruct.tokenID; - ASSERT_EQ(RET_SUCCESS, ret); + ASSERT_NE(INVALID_TOKENID, tokenID); + + ASSERT_FALSE(AccessTokenKit::IsSystemAppByFullTokenID(fullTokenId.tokenIDEx)); HapTokenInfo hapInfo; - AccessTokenKit::GetHapTokenInfo(tokenID, hapInfo); - EXPECT_EQ(0, hapInfo.userID); - EXPECT_EQ("com.ohos.AccessTokenTestBundle", hapInfo.bundleName); - EXPECT_EQ(TestCommon::DEFAULT_API_VERSION, hapInfo.apiVersion); - EXPECT_EQ(0, hapInfo.instIndex); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GetHapTokenInfo(tokenID, hapInfo)); + EXPECT_EQ(infoParams.userID, hapInfo.userID); + EXPECT_EQ(infoParams.bundleName, hapInfo.bundleName); + EXPECT_EQ(infoParams.apiVersion, hapInfo.apiVersion); + EXPECT_EQ(infoParams.instIndex, hapInfo.instIndex); EXPECT_EQ(tokenID, hapInfo.tokenID); - EXPECT_EQ(0, hapInfo.tokenAttr); HapTokenInfoExt hapInfoExt; - AccessTokenKit::GetHapTokenInfoExtension(tokenID, hapInfoExt); - EXPECT_EQ("AccessTokenTestAppID", hapInfoExt.appID); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GetHapTokenInfoExtension(tokenID, hapInfoExt)); + EXPECT_EQ(infoParams.appIDDesc, hapInfoExt.appID); ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); } @@ -173,27 +172,30 @@ HWTEST_F(InitHapTokenTest, InitHapTokenFuncTest001, TestSize.Level1) HWTEST_F(InitHapTokenTest, InitHapTokenFuncTest002, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "InitHapTokenFuncTest002"); + MockNativeToken mock("foundation"); HapInfoParams infoParams; HapPolicyParams policyParams; TestCommon::GetHapParams(infoParams, policyParams); + infoParams.isSystemApp = true; AccessTokenIDEx fullTokenId; - int32_t ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId)); AccessTokenID tokenID = fullTokenId.tokenIdExStruct.tokenID; - ASSERT_EQ(RET_SUCCESS, ret); + ASSERT_NE(INVALID_TOKENID, tokenID); + + ASSERT_TRUE(AccessTokenKit::IsSystemAppByFullTokenID(fullTokenId.tokenIDEx)); HapTokenInfo hapInfo; - AccessTokenKit::GetHapTokenInfo(tokenID, hapInfo); - EXPECT_EQ(0, hapInfo.userID); - EXPECT_EQ("com.ohos.AccessTokenTestBundle", hapInfo.bundleName); - EXPECT_EQ(TestCommon::DEFAULT_API_VERSION, hapInfo.apiVersion); - EXPECT_EQ(0, hapInfo.instIndex); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GetHapTokenInfo(tokenID, hapInfo)); + EXPECT_EQ(infoParams.userID, hapInfo.userID); + EXPECT_EQ(infoParams.bundleName, hapInfo.bundleName); + EXPECT_EQ(infoParams.apiVersion, hapInfo.apiVersion); + EXPECT_EQ(infoParams.instIndex, hapInfo.instIndex); EXPECT_EQ(tokenID, hapInfo.tokenID); - EXPECT_EQ(1, hapInfo.tokenAttr); HapTokenInfoExt hapInfoExt; - AccessTokenKit::GetHapTokenInfoExtension(tokenID, hapInfoExt); - EXPECT_EQ("AccessTokenTestAppID", hapInfoExt.appID); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GetHapTokenInfoExtension(tokenID, hapInfoExt)); + EXPECT_EQ(infoParams.appIDDesc, hapInfoExt.appID); ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); } @@ -207,6 +209,7 @@ HWTEST_F(InitHapTokenTest, InitHapTokenFuncTest002, TestSize.Level1) HWTEST_F(InitHapTokenTest, InitHapTokenFuncTest003, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "InitHapTokenFuncTest003"); + MockNativeToken mock("foundation"); HapInfoParams infoParams; HapPolicyParams policyParams; @@ -230,13 +233,14 @@ HWTEST_F(InitHapTokenTest, InitHapTokenFuncTest003, TestSize.Level1) }; policyParams.permStateList = {permissionStateFull001, permissionStateFull002}; AccessTokenIDEx fullTokenId; - int32_t ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId)); AccessTokenID tokenID = fullTokenId.tokenIdExStruct.tokenID; - ASSERT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.ACCESS_CERT_MANAGER"); - EXPECT_EQ(PERMISSION_GRANTED, ret); - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.ACCESS_CERT_MANAGER_INTERNAL"); - EXPECT_EQ(PERMISSION_GRANTED, ret); + ASSERT_NE(INVALID_TOKENID, tokenID); + + EXPECT_EQ(PERMISSION_GRANTED, + AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.ACCESS_CERT_MANAGER")); + EXPECT_EQ(PERMISSION_GRANTED, + AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.ACCESS_CERT_MANAGER_INTERNAL")); ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); } @@ -250,10 +254,10 @@ HWTEST_F(InitHapTokenTest, InitHapTokenFuncTest003, TestSize.Level1) HWTEST_F(InitHapTokenTest, InitHapTokenFuncTest004, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "InitHapTokenFuncTest004"); + MockNativeToken mock("foundation"); AccessTokenIDEx fullTokenId; - int32_t ret = AccessTokenKit::InitHapToken(g_testHapInfoParams, g_testPolicyParams, fullTokenId); - EXPECT_EQ(RET_SUCCESS, ret); + EXPECT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(g_testHapInfoParams, g_testPolicyParams, fullTokenId)); ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(fullTokenId.tokenIdExStruct.tokenID)); ASSERT_NE(RET_SUCCESS, AccessTokenKit::DeleteToken(fullTokenId.tokenIdExStruct.tokenID)); } @@ -267,6 +271,7 @@ HWTEST_F(InitHapTokenTest, InitHapTokenFuncTest004, TestSize.Level1) HWTEST_F(InitHapTokenTest, InitHapTokenFuncTest005, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "InitHapTokenFuncTest005"); + MockNativeToken mock("foundation"); HapInfoParams infoParams; HapPolicyParams policyParams; @@ -275,31 +280,31 @@ HWTEST_F(InitHapTokenTest, InitHapTokenFuncTest005, TestSize.Level1) policyParams.permStateList = { g_infoManagerCameraState, g_infoManagerMicrophoneState, g_infoManagerCertState }; AccessTokenIDEx fullTokenId; - int32_t res = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); - EXPECT_EQ(RET_SUCCESS, res); + EXPECT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId)); HapInfoParams infoParams1 = infoParams; infoParams1.dlpType = DLP_FULL_CONTROL; infoParams1.instIndex++; AccessTokenIDEx dlpFullTokenId1; - res = AccessTokenKit::InitHapToken(infoParams1, policyParams, dlpFullTokenId1); - EXPECT_EQ(RET_SUCCESS, res); + EXPECT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(infoParams1, policyParams, dlpFullTokenId1)); - res = AccessTokenKit::VerifyAccessToken(dlpFullTokenId1.tokenIdExStruct.tokenID, "ohos.permission.CAMERA"); + int32_t res = AccessTokenKit::VerifyAccessToken( + dlpFullTokenId1.tokenIdExStruct.tokenID, g_infoManagerCameraState.permissionName); EXPECT_EQ(res, PERMISSION_DENIED); (void)AccessTokenKit::GrantPermission( - fullTokenId.tokenIdExStruct.tokenID, "ohos.permission.CAMERA", PERMISSION_USER_SET); + fullTokenId.tokenIdExStruct.tokenID, g_infoManagerCameraState.permissionName, PERMISSION_USER_SET); (void)AccessTokenKit::RevokePermission( - fullTokenId.tokenIdExStruct.tokenID, "ohos.permission.MICROPHONE", PERMISSION_USER_SET); + fullTokenId.tokenIdExStruct.tokenID, g_infoManagerMicrophoneState.permissionName, PERMISSION_USER_SET); infoParams1.instIndex++; AccessTokenIDEx dlpFullTokenId2; - res = AccessTokenKit::InitHapToken(infoParams1, policyParams, dlpFullTokenId2); - EXPECT_EQ(RET_SUCCESS, res); - res = AccessTokenKit::VerifyAccessToken(dlpFullTokenId2.tokenIdExStruct.tokenID, "ohos.permission.CAMERA"); + EXPECT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(infoParams1, policyParams, dlpFullTokenId2)); + res = AccessTokenKit::VerifyAccessToken( + dlpFullTokenId2.tokenIdExStruct.tokenID, g_infoManagerCameraState.permissionName); EXPECT_EQ(res, PERMISSION_GRANTED); - res = AccessTokenKit::VerifyAccessToken(dlpFullTokenId1.tokenIdExStruct.tokenID, "ohos.permission.CAMERA"); + res = AccessTokenKit::VerifyAccessToken( + dlpFullTokenId1.tokenIdExStruct.tokenID, g_infoManagerCameraState.permissionName); EXPECT_EQ(res, PERMISSION_GRANTED); std::vector permStatList1; @@ -330,6 +335,7 @@ HWTEST_F(InitHapTokenTest, InitHapTokenFuncTest005, TestSize.Level1) HWTEST_F(InitHapTokenTest, InitHapTokenFuncTest006, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "InitHapTokenFuncTest006"); + MockNativeToken mock("foundation"); HapInfoParams infoParams; HapPolicyParams policyParams; @@ -339,9 +345,9 @@ HWTEST_F(InitHapTokenTest, InitHapTokenFuncTest006, TestSize.Level1) HapInfoCheckResult result; result.permCheckResult.permissionName = "test"; // invalid Name result.permCheckResult.rule = static_cast(-1); // invalid reasan - int32_t ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId, result); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId, result)); AccessTokenID tokenID = fullTokenId.tokenIdExStruct.tokenID; - ASSERT_EQ(RET_SUCCESS, ret); + ASSERT_NE(INVALID_TOKENID, tokenID); ASSERT_EQ(result.permCheckResult.permissionName, "test"); ASSERT_EQ(result.permCheckResult.rule, -1); @@ -357,6 +363,7 @@ HWTEST_F(InitHapTokenTest, InitHapTokenFuncTest006, TestSize.Level1) HWTEST_F(InitHapTokenTest, InitHapTokenFuncTest007, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "InitHapTokenFuncTest007"); + MockNativeToken mock("foundation"); HapInfoParams infoParams; HapPolicyParams policyParams; @@ -369,25 +376,27 @@ HWTEST_F(InitHapTokenTest, InitHapTokenFuncTest007, TestSize.Level1) .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED} }; policyParams.permStateList.emplace_back(permStatDump); + + // init fail, acl check fail AccessTokenIDEx fullTokenId; - int32_t ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); - ASSERT_EQ(ERR_PERM_REQUEST_CFG_FAILED, ret); + ASSERT_EQ(ERR_PERM_REQUEST_CFG_FAILED, AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId)); + policyParams.checkIgnore = HapPolicyCheckIgnore::ACL_IGNORE_CHECK; - ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); - ASSERT_EQ(RET_SUCCESS, ret); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId)); AccessTokenID tokenID = fullTokenId.tokenIdExStruct.tokenID; ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); } /** * @tc.name: InitHapTokenSpecsTest001 - * @tc.desc: Test the high-level permission authorized by acl. + * @tc.desc: Test request the high-level permission authorized by acl. * @tc.type: FUNC * @tc.require: */ HWTEST_F(InitHapTokenTest, InitHapTokenSpecsTest001, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "InitHapTokenSpecsTest001"); + MockNativeToken mock("foundation"); HapInfoParams infoParams; HapPolicyParams policyParams; @@ -413,11 +422,10 @@ HWTEST_F(InitHapTokenTest, InitHapTokenSpecsTest001, TestSize.Level1) policyParams.permStateList = {permissionStateFull001, permissionStateFull002}; policyParams.aclRequestedList = {"ohos.permission.ACCESS_DDK_USB"}; AccessTokenIDEx fullTokenId; - int32_t ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId)); AccessTokenID tokenID = fullTokenId.tokenIdExStruct.tokenID; - ASSERT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.RUN_DYN_CODE"); + int32_t ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.RUN_DYN_CODE"); EXPECT_EQ(PERMISSION_GRANTED, ret); ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.ACCESS_DDK_USB"); EXPECT_EQ(PERMISSION_GRANTED, ret); @@ -434,6 +442,7 @@ HWTEST_F(InitHapTokenTest, InitHapTokenSpecsTest001, TestSize.Level1) HWTEST_F(InitHapTokenTest, InitHapTokenSpecsTest002, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "InitHapTokenSpecsTest002"); + MockNativeToken mock("foundation"); HapInfoParams infoParams; HapPolicyParams policyParams; @@ -458,12 +467,8 @@ HWTEST_F(InitHapTokenTest, InitHapTokenSpecsTest002, TestSize.Level1) policyParams.permStateList = {permissionStateFull001, permissionStateFull002}; AccessTokenIDEx fullTokenId; - int32_t ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); - ASSERT_EQ(ERR_PERM_REQUEST_CFG_FAILED, ret); - HapInfoCheckResult result; - ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId, result); - ASSERT_EQ(ERR_PERM_REQUEST_CFG_FAILED, ret); + ASSERT_EQ(ERR_PERM_REQUEST_CFG_FAILED, AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId, result)); ASSERT_EQ(result.permCheckResult.permissionName, "ohos.permission.ACCESS_DDK_USB"); ASSERT_EQ(result.permCheckResult.rule, PERMISSION_ACL_RULE); } @@ -477,6 +482,7 @@ HWTEST_F(InitHapTokenTest, InitHapTokenSpecsTest002, TestSize.Level1) HWTEST_F(InitHapTokenTest, InitHapTokenSpecsTest003, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "InitHapTokenSpecsTest003"); + MockNativeToken mock("foundation"); HapInfoParams infoParams; HapPolicyParams policyParams; @@ -502,11 +508,10 @@ HWTEST_F(InitHapTokenTest, InitHapTokenSpecsTest003, TestSize.Level1) policyParams.permStateList = {permissionStateFull001, permissionStateFull002}; AccessTokenIDEx fullTokenId; - int32_t ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId)); AccessTokenID tokenID = fullTokenId.tokenIdExStruct.tokenID; - ASSERT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.READ_HEALTH_MOTION"); + int32_t ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.READ_HEALTH_MOTION"); EXPECT_EQ(PERMISSION_GRANTED, ret); ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.READ_WRITE_DESKTOP_DIRECTORY"); EXPECT_EQ(PERMISSION_DENIED, ret); @@ -531,6 +536,7 @@ HWTEST_F(InitHapTokenTest, InitHapTokenSpecsTest003, TestSize.Level1) HWTEST_F(InitHapTokenTest, InitHapTokenSpecsTest004, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "InitHapTokenSpecsTest004"); + MockNativeToken mock("foundation"); HapInfoParams infoParams; HapPolicyParams policyParams; @@ -564,11 +570,10 @@ HWTEST_F(InitHapTokenTest, InitHapTokenSpecsTest004, TestSize.Level1) }; policyParams.preAuthorizationInfo = {preAuthorizationInfo001, preAuthorizationInfo002}; AccessTokenIDEx fullTokenId; - int32_t ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId)); AccessTokenID tokenID = fullTokenId.tokenIdExStruct.tokenID; - ASSERT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.ACCESS_NEARLINK"); + int32_t ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.ACCESS_NEARLINK"); EXPECT_EQ(PERMISSION_GRANTED, ret); ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.READ_WRITE_DESKTOP_DIRECTORY"); EXPECT_EQ(PERMISSION_GRANTED, ret); @@ -595,6 +600,7 @@ HWTEST_F(InitHapTokenTest, InitHapTokenSpecsTest004, TestSize.Level1) HWTEST_F(InitHapTokenTest, InitHapTokenSpecsTest005, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "InitHapTokenSpecsTest005"); + MockNativeToken mock("foundation"); HapInfoParams infoParams; HapPolicyParams policyParams; @@ -623,6 +629,7 @@ HWTEST_F(InitHapTokenTest, InitHapTokenSpecsTest005, TestSize.Level1) HWTEST_F(InitHapTokenTest, InitHapTokenSpecsTest006, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "InitHapTokenSpecsTest006"); + MockNativeToken mock("foundation"); HapInfoParams infoParams; HapPolicyParams policyParams; @@ -662,6 +669,7 @@ HWTEST_F(InitHapTokenTest, InitHapTokenSpecsTest006, TestSize.Level1) HWTEST_F(InitHapTokenTest, InitHapTokenSpecsTest007, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "InitHapTokenSpecsTest007"); + MockNativeToken mock("foundation"); HapInfoParams infoParams; HapPolicyParams policyParams; @@ -683,7 +691,6 @@ HWTEST_F(InitHapTokenTest, InitHapTokenSpecsTest007, TestSize.Level1) HapInfoCheckResult result; ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId, result); - tokenID = fullTokenId.tokenIdExStruct.tokenID; ASSERT_EQ(ERR_PERM_REQUEST_CFG_FAILED, ret); ASSERT_EQ(result.permCheckResult.permissionName, "ohos.permission.ENTERPRISE_MANAGE_SETTINGS"); ASSERT_EQ(result.permCheckResult.rule, PERMISSION_EDM_RULE); @@ -701,6 +708,7 @@ HWTEST_F(InitHapTokenTest, InitHapTokenSpecsTest007, TestSize.Level1) HWTEST_F(InitHapTokenTest, InitHapTokenSpecsTest008, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "InitHapTokenSpecsTest008"); + MockNativeToken mock("foundation"); HapInfoParams infoParams; HapPolicyParams policyParams; @@ -731,6 +739,201 @@ HWTEST_F(InitHapTokenTest, InitHapTokenSpecsTest008, TestSize.Level1) ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); } +/** + * @tc.name: InitHapTokenSpecsTest009 + * @tc.desc: InitHapToken isRestore with real token + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(InitHapTokenTest, InitHapTokenSpecsTest009, TestSize.Level1) +{ + MockNativeToken mock("foundation"); + HapInfoParams infoParams; + HapPolicyParams policyParams; + TestCommon::GetHapParams(infoParams, policyParams); + policyParams.apl = APL_SYSTEM_CORE; + + PermissionStateFull permissionStateFull001 = { + .permissionName = "ohos.permission.ACCESS_CERT_MANAGER", + .isGeneral = false, + .resDeviceID = {"local"}, + .grantStatus = {PERMISSION_GRANTED}, + .grantFlags = {PERMISSION_SYSTEM_FIXED} + }; + + policyParams.permStateList = {permissionStateFull001, g_infoManagerCameraState}; + AccessTokenIDEx fullTokenId; + int32_t ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); + AccessTokenID tokenID = fullTokenId.tokenIdExStruct.tokenID; + ASSERT_EQ(RET_SUCCESS, ret); + + ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.ACCESS_CERT_MANAGER"); + EXPECT_EQ(PERMISSION_GRANTED, ret); + + (void)AccessTokenKit::GrantPermission(tokenID, "ohos.permission.CAMERA", PERMISSION_USER_SET); + ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.CAMERA"); + EXPECT_EQ(ret, PERMISSION_GRANTED); + + ret = AccessTokenKit::DeleteToken(tokenID); + EXPECT_EQ(RET_SUCCESS, ret); + + infoParams.isRestore = true; + infoParams.tokenID = tokenID; + ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); + EXPECT_EQ(RET_SUCCESS, ret); + + ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.ACCESS_CERT_MANAGER"); + EXPECT_EQ(PERMISSION_GRANTED, ret); + + ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.CAMERA"); + EXPECT_EQ(ret, PERMISSION_DENIED); + + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); +} + +/** + * @tc.name: InitHapTokenSpecsTest010 + * @tc.desc: aclExtendedMap size test + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(InitHapTokenTest, InitHapTokenSpecsTest010, TestSize.Level1) +{ + HapInfoParams infoParams; + HapPolicyParams policyParams; + TestCommon::GetHapParams(infoParams, policyParams); + policyParams.apl = APL_SYSTEM_CORE; + + AccessTokenIDEx fullTokenId; + int32_t ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); + ASSERT_EQ(RET_SUCCESS, ret); + + for (size_t i = 0; i < MAX_EXTENDED_MAP_SIZE - 1; i++) { + policyParams.aclExtendedMap[std::to_string(i)] = std::to_string(i); + } + ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); + ASSERT_EQ(RET_SUCCESS, ret); + + policyParams.aclExtendedMap[std::to_string(MAX_EXTENDED_MAP_SIZE - 1)] = + std::to_string(MAX_EXTENDED_MAP_SIZE - 1); + ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); + ASSERT_EQ(RET_SUCCESS, ret); + + policyParams.aclExtendedMap[std::to_string(MAX_EXTENDED_MAP_SIZE)] = + std::to_string(MAX_EXTENDED_MAP_SIZE); + ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); + ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); + AccessTokenID tokenID = fullTokenId.tokenIdExStruct.tokenID; + ret = AccessTokenKit::DeleteToken(tokenID); + EXPECT_EQ(RET_SUCCESS, ret); +} + +/** + * @tc.name: InitHapTokenSpecsTest011 + * @tc.desc: aclExtendedMap content size test + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(InitHapTokenTest, InitHapTokenSpecsTest011, TestSize.Level1) +{ + HapInfoParams infoParams; + HapPolicyParams policyParams; + TestCommon::GetHapParams(infoParams, policyParams); + policyParams.apl = APL_SYSTEM_CORE; + + AccessTokenIDEx fullTokenId; + policyParams.aclExtendedMap["ohos.permission.ACCESS_CERT_MANAGER"] = ""; + int32_t ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); + ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); + + std::string testValue(MAX_VALUE_LENGTH - 1, '1'); + policyParams.aclExtendedMap["ohos.permission.ACCESS_CERT_MANAGER"] = testValue; + ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); + ASSERT_EQ(RET_SUCCESS, ret); + + testValue.push_back('1'); + policyParams.aclExtendedMap["ohos.permission.ACCESS_CERT_MANAGER"] = testValue; + ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); + ASSERT_EQ(RET_SUCCESS, ret); + + testValue.push_back('1'); + policyParams.aclExtendedMap["ohos.permission.ACCESS_CERT_MANAGER"] = testValue; + ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); + ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); + AccessTokenID tokenID = fullTokenId.tokenIdExStruct.tokenID; + + ret = AccessTokenKit::DeleteToken(tokenID); + EXPECT_EQ(RET_SUCCESS, ret); +} + +/** + * @tc.name: InitHapTokenSpecsTest012 + * @tc.desc: InitHapToken permission with value + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(InitHapTokenTest, InitHapTokenSpecsTest012, TestSize.Level1) +{ + HapInfoParams infoParams; + HapPolicyParams policyParams; + TestCommon::GetHapParams(infoParams, policyParams); + policyParams.apl = APL_SYSTEM_CORE; + TestCommon::TestPrepareKernelPermissionDefinition(infoParams, policyParams); + TestCommon::TestPrepareKernelPermissionStatus(policyParams); + AccessTokenIDEx fullTokenId; + int32_t ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); + ASSERT_EQ(RET_SUCCESS, ret); + AccessTokenID tokenID = fullTokenId.tokenIdExStruct.tokenID; + + std::vector kernelPermList; + ret = AccessTokenKit::GetKernelPermissions(tokenID, kernelPermList); + ASSERT_EQ(RET_SUCCESS, ret); + ASSERT_EQ(0, kernelPermList.size()); + + std::string value; + ret = AccessTokenKit::GetReqPermissionByName( + tokenID, "ohos.permission.kernel.ALLOW_WRITABLE_CODE_MEMORY", value); + ASSERT_NE(RET_SUCCESS, ret); + ASSERT_NE("123", value); + + ret = AccessTokenKit::GetReqPermissionByName( + tokenID, "ohos.permission.kernel.ALLOW_EXECUTABLE_FORT_MEMORY", value); + ASSERT_NE(RET_SUCCESS, ret); + ASSERT_NE("456", value); + + ret = AccessTokenKit::DeleteToken(tokenID); + EXPECT_EQ(RET_SUCCESS, ret); +} + +/** + * @tc.name: InitHapTokenSpecsTest013 + * @tc.desc: InitHapToken is called repeatly, tokenId will change + * 1. first tokenId is delete; 2. second token is valid + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(InitHapTokenTest, InitHapTokenSpecsTest013, TestSize.Level1) +{ + MockNativeToken mock("foundation"); + HapInfoParams infoParams; + HapPolicyParams policyParams; + TestCommon::GetHapParams(infoParams, policyParams); + AccessTokenIDEx tokenIdEx1; + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(infoParams, policyParams, tokenIdEx1)); + + AccessTokenIDEx tokenIdEx2; + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(infoParams, policyParams, tokenIdEx2)); + + ASSERT_NE(tokenIdEx1.tokenIdExStruct.tokenID, tokenIdEx2.tokenIdExStruct.tokenID); + + HapTokenInfo hapInfo; + ASSERT_EQ(ERR_TOKENID_NOT_EXIST, AccessTokenKit::GetHapTokenInfo(tokenIdEx1.tokenIdExStruct.tokenID, hapInfo)); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GetHapTokenInfo(tokenIdEx2.tokenIdExStruct.tokenID, hapInfo)); + + EXPECT_EQ(ERR_PARAM_INVALID, AccessTokenKit::DeleteToken(tokenIdEx1.tokenIdExStruct.tokenID)); + EXPECT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenIdEx2.tokenIdExStruct.tokenID)); +} + /** * @tc.name: InitHapTokenAbnormalTest001 * @tc.desc: Invaild HapInfoParams. @@ -832,11 +1035,12 @@ HWTEST_F(InitHapTokenTest, InitHapTokenAbnormalTest003, TestSize.Level1) policyParams.permStateList.emplace_back(permissionStateFull001); policyParams.permStateList.emplace_back(permissionStateFull002); AccessTokenIDEx fullTokenId; - int32_t ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); - ASSERT_EQ(RET_SUCCESS, ret); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId)); AccessTokenID tokenID = fullTokenId.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + std::vector reqPermList; - ret = AccessTokenKit::GetReqPermissions(tokenID, reqPermList, false); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GetReqPermissions(tokenID, reqPermList, false)); EXPECT_TRUE(reqPermList.empty()); ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); @@ -872,31 +1076,39 @@ HWTEST_F(InitHapTokenTest, InitHapTokenAbnormalTest004, TestSize.Level1) }; policyParams.aclRequestedList = {""}; AccessTokenIDEx fullTokenId; - int32_t ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); - EXPECT_EQ(RET_SUCCESS, ret); + EXPECT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId)); AccessTokenID tokenID = fullTokenId.tokenIdExStruct.tokenID; - ret = AccessTokenKit::VerifyAccessToken(tokenID, ""); + EXPECT_NE(INVALID_TOKENID, tokenID); + int32_t ret = AccessTokenKit::VerifyAccessToken(tokenID, ""); EXPECT_EQ(PERMISSION_DENIED, ret); policyParams.aclRequestedList = {"ohos.permission.test"}; - ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); - EXPECT_EQ(RET_SUCCESS, ret); + EXPECT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId)); + EXPECT_NE(INVALID_TOKENID, fullTokenId.tokenIdExStruct.tokenID); + EXPECT_NE(tokenID, fullTokenId.tokenIdExStruct.tokenID); + tokenID = fullTokenId.tokenIdExStruct.tokenID; ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.test"); EXPECT_EQ(PERMISSION_DENIED, ret); policyParams.aclRequestedList = {"ohos.permission.AGENT_REQUIRE_FORM"}; - ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); - ASSERT_EQ(RET_SUCCESS, ret); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId)); + EXPECT_NE(INVALID_TOKENID, fullTokenId.tokenIdExStruct.tokenID); + EXPECT_NE(tokenID, fullTokenId.tokenIdExStruct.tokenID); + tokenID = fullTokenId.tokenIdExStruct.tokenID; ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.AGENT_REQUIRE_FORM"); EXPECT_EQ(PERMISSION_DENIED, ret); policyParams.permStateList.emplace_back(permissionStateFull002); policyParams.aclRequestedList.emplace_back("ohos.permission.ACCESS_EXTENSIONAL_DEVICE_DRIVER"); - ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); - ASSERT_EQ(RET_SUCCESS, ret); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId)); + EXPECT_NE(INVALID_TOKENID, fullTokenId.tokenIdExStruct.tokenID); + EXPECT_NE(tokenID, fullTokenId.tokenIdExStruct.tokenID); + tokenID = fullTokenId.tokenIdExStruct.tokenID; ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.ACCESS_EXTENSIONAL_DEVICE_DRIVER"); - EXPECT_EQ(PERMISSION_DENIED, ret); + EXPECT_EQ(PERMISSION_GRANTED, ret); + + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); } /** @@ -917,25 +1129,30 @@ HWTEST_F(InitHapTokenTest, InitHapTokenAbnormalTest005, TestSize.Level1) preAuthorizationInfo.permissionName = ""; policyParams.preAuthorizationInfo = {preAuthorizationInfo}; AccessTokenIDEx fullTokenId; - int32_t ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); - EXPECT_EQ(RET_SUCCESS, ret); + EXPECT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId)); AccessTokenID tokenID = fullTokenId.tokenIdExStruct.tokenID; - ret = AccessTokenKit::VerifyAccessToken(tokenID, ""); - EXPECT_EQ(PERMISSION_DENIED, ret); + EXPECT_NE(INVALID_TOKENID, tokenID); + EXPECT_EQ(PERMISSION_DENIED, AccessTokenKit::VerifyAccessToken(tokenID, "")); preAuthorizationInfo.permissionName = "ohos.permission.test"; policyParams.preAuthorizationInfo = {preAuthorizationInfo}; - ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); - EXPECT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.test"); + EXPECT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId)); + EXPECT_NE(INVALID_TOKENID, fullTokenId.tokenIdExStruct.tokenID); + EXPECT_NE(tokenID, fullTokenId.tokenIdExStruct.tokenID); + tokenID = fullTokenId.tokenIdExStruct.tokenID; + int32_t ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.test"); EXPECT_EQ(PERMISSION_DENIED, ret); preAuthorizationInfo.permissionName = "ohos.permission.AGENT_REQUIRE_FORM"; policyParams.preAuthorizationInfo = {preAuthorizationInfo}; - ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); - ASSERT_EQ(RET_SUCCESS, ret); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId)); + EXPECT_NE(INVALID_TOKENID, fullTokenId.tokenIdExStruct.tokenID); + EXPECT_NE(tokenID, fullTokenId.tokenIdExStruct.tokenID); + tokenID = fullTokenId.tokenIdExStruct.tokenID; ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.AGENT_REQUIRE_FORM"); EXPECT_EQ(PERMISSION_DENIED, ret); + + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(fullTokenId.tokenIdExStruct.tokenID)); } /** @@ -960,172 +1177,6 @@ HWTEST_F(InitHapTokenTest, InitHapTokenAbnormalTest006, TestSize.Level1) int32_t ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); EXPECT_EQ(ERR_PARAM_INVALID, ret); } - -/** - * @tc.name: InitHapTokenSpecsTest009 - * @tc.desc: InitHapToken isRestore with real token - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(InitHapTokenTest, InitHapTokenSpecsTest009, TestSize.Level1) -{ - HapInfoParams infoParams; - HapPolicyParams policyParams; - TestCommon::GetHapParams(infoParams, policyParams); - policyParams.apl = APL_SYSTEM_CORE; - - PermissionStateFull permissionStateFull001 = { - .permissionName = "ohos.permission.ACCESS_CERT_MANAGER", - .isGeneral = false, - .resDeviceID = {"local"}, - .grantStatus = {PERMISSION_GRANTED}, - .grantFlags = {PERMISSION_SYSTEM_FIXED} - }; - - policyParams.permStateList = {permissionStateFull001, g_infoManagerCameraState}; - AccessTokenIDEx fullTokenId; - int32_t ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); - AccessTokenID tokenID = fullTokenId.tokenIdExStruct.tokenID; - ASSERT_EQ(RET_SUCCESS, ret); - - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.ACCESS_CERT_MANAGER"); - EXPECT_EQ(PERMISSION_GRANTED, ret); - - (void)AccessTokenKit::GrantPermission(tokenID, "ohos.permission.CAMERA", PERMISSION_USER_SET); - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.CAMERA"); - EXPECT_EQ(ret, PERMISSION_GRANTED); - - ret = AccessTokenKit::DeleteToken(tokenID); - EXPECT_EQ(RET_SUCCESS, ret); - - infoParams.isRestore = true; - infoParams.tokenID = tokenID; - ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); - EXPECT_EQ(RET_SUCCESS, ret); - - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.ACCESS_CERT_MANAGER"); - EXPECT_EQ(PERMISSION_GRANTED, ret); - - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.CAMERA"); - EXPECT_EQ(ret, PERMISSION_DENIED); -} - -/** - * @tc.name: InitHapTokenSpecsTest010 - * @tc.desc: aclExtendedMap size test - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(InitHapTokenTest, InitHapTokenSpecsTest010, TestSize.Level1) -{ - HapInfoParams infoParams; - HapPolicyParams policyParams; - TestCommon::GetHapParams(infoParams, policyParams); - policyParams.apl = APL_SYSTEM_CORE; - - AccessTokenIDEx fullTokenId; - int32_t ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); - ASSERT_EQ(RET_SUCCESS, ret); - - for (size_t i = 0; i < MAX_EXTENDED_MAP_SIZE - 1; i++) { - policyParams.aclExtendedMap[std::to_string(i)] = std::to_string(i); - } - ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); - ASSERT_EQ(RET_SUCCESS, ret); - - policyParams.aclExtendedMap[std::to_string(MAX_EXTENDED_MAP_SIZE - 1)] = - std::to_string(MAX_EXTENDED_MAP_SIZE - 1); - ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); - ASSERT_EQ(RET_SUCCESS, ret); - - policyParams.aclExtendedMap[std::to_string(MAX_EXTENDED_MAP_SIZE)] = - std::to_string(MAX_EXTENDED_MAP_SIZE); - ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); - AccessTokenID tokenID = fullTokenId.tokenIdExStruct.tokenID; - ret = AccessTokenKit::DeleteToken(tokenID); - EXPECT_EQ(RET_SUCCESS, ret); -} - -/** - * @tc.name: InitHapTokenSpecsTest011 - * @tc.desc: aclExtendedMap content size test - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(InitHapTokenTest, InitHapTokenSpecsTest011, TestSize.Level1) -{ - HapInfoParams infoParams; - HapPolicyParams policyParams; - TestCommon::GetHapParams(infoParams, policyParams); - policyParams.apl = APL_SYSTEM_CORE; - - AccessTokenIDEx fullTokenId; - policyParams.aclExtendedMap["ohos.permission.ACCESS_CERT_MANAGER"] = ""; - int32_t ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); - - std::string testValue(MAX_VALUE_LENGTH - 1, '1'); - policyParams.aclExtendedMap["ohos.permission.ACCESS_CERT_MANAGER"] = testValue; - ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); - ASSERT_EQ(RET_SUCCESS, ret); - - testValue.push_back('1'); - policyParams.aclExtendedMap["ohos.permission.ACCESS_CERT_MANAGER"] = testValue; - ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); - ASSERT_EQ(RET_SUCCESS, ret); - - testValue.push_back('1'); - policyParams.aclExtendedMap["ohos.permission.ACCESS_CERT_MANAGER"] = testValue; - ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); - AccessTokenID tokenID = fullTokenId.tokenIdExStruct.tokenID; - - ret = AccessTokenKit::DeleteToken(tokenID); - EXPECT_EQ(RET_SUCCESS, ret); -} - -/** - * @tc.name: InitHapTokenSpecsTest012 - * @tc.desc: InitHapToken permission with value - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(InitHapTokenTest, InitHapTokenSpecsTest012, TestSize.Level1) -{ - HapInfoParams infoParams; - HapPolicyParams policyParams; - TestCommon::GetHapParams(infoParams, policyParams); - policyParams.apl = APL_SYSTEM_CORE; - TestCommon::TestPrepareKernelPermissionDefinition(infoParams, policyParams); - TestCommon::TestPrepareKernelPermissionStatus(policyParams); - AccessTokenIDEx fullTokenId; - int32_t ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); - AccessTokenID tokenID = fullTokenId.tokenIdExStruct.tokenID; - ASSERT_EQ(RET_SUCCESS, ret); - - // switch to shell token - SetSelfTokenID(g_selfTokenId); - - std::vector kernelPermList; - ret = AccessTokenKit::GetKernelPermissions(tokenID, kernelPermList); - ASSERT_EQ(RET_SUCCESS, ret); - ASSERT_EQ(0, kernelPermList.size()); - - std::string value; - ret = AccessTokenKit::GetReqPermissionByName( - tokenID, "ohos.permission.kernel.ALLOW_WRITABLE_CODE_MEMORY", value); - ASSERT_EQ(RET_SUCCESS, ret); - ASSERT_EQ("123", value); - - ret = AccessTokenKit::GetReqPermissionByName( - tokenID, "ohos.permission.kernel.ALLOW_EXECUTABLE_FORT_MEMORY", value); - ASSERT_EQ(RET_SUCCESS, ret); - ASSERT_EQ("456", value); - - ret = AccessTokenKit::DeleteToken(tokenID); - EXPECT_EQ(RET_SUCCESS, ret); -} } // namespace AccessToken } // namespace Security } // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/accesstoken/test/unittest/HapTokenTest/update_hap_token_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/HapTokenTest/update_hap_token_test.cpp index 5cad532a4f916c218b35052bda65a9ffcb5f1380..68b2b36fa12fd2a512079fab04e749101df3cbe6 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/HapTokenTest/update_hap_token_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/HapTokenTest/update_hap_token_test.cpp @@ -34,23 +34,21 @@ namespace OHOS { namespace Security { namespace AccessToken { namespace { -static AccessTokenID g_selfTokenId = 0; +static const std::string TEST_BUNDLE_NAME = "ohos"; +static const int TEST_USER_ID = 0; +static const int THREAD_NUM = 3; +static constexpr int32_t CYCLE_TIMES = 100; +static const int INVALID_APPIDDESC_LEN = 10244; +static const int32_t INDEX_ZERO = 0; +static uint64_t g_selfTokenId = 0; static constexpr int32_t API_VERSION_EIGHT = 8; -static constexpr int32_t THIRTY_TIME_CYCLES = 30; const std::string APP_DISTRIBUTION_TYPE_ENTERPRISE_MDM = "enterprise_mdm"; const std::string OVER_SIZE_STR = "AAANSUhEUgAAABUAAAAXCAIAAABrvZPKAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAAEXRFWHRTb2Z0d2FyZQBTbmlwYXN0ZV0Xzt0A" "FBSURBVDiN7ZQ/S8NQFMVPxU/QCx06GBzrkqUZ42rBbHWUBDqYxSnUoTxXydCSycVsgltfBiFDR8HNdHGxY4nQQAPvMzwHsWn+KM" "vj3He5vIaUEjV0UAfe85X83KMBT7N75JEXVdSlfEAVfPRyZ5yfIrBoUkVlMU82Hkp8wu9ddt1vFew4sIiIiKwgzcXIvN7GTZOvpZ" "D3I1NZvmdCXz+XOv5wJANKHOVYjRTAghxIyh0FHKb+0QQH5+kXf2zkYGAG0oFr5RfnK8DAGkwY19wliRT2L448vjv0YGQFVa8VKd"; - -PermissionStateFull g_testPermReq = { - .permissionName = "ohos.permission.MANAGE_HAP_TOKENID", - .isGeneral = true, - .resDeviceID = {"test_device"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED} -}; +static MockNativeToken* g_mock; PermissionStateFull g_infoManagerCameraState = { .permissionName = "ohos.permission.CAMERA", @@ -68,14 +66,6 @@ PermissionStateFull g_infoManagerMicrophoneState = { .grantFlags = {0} }; -PermissionStateFull g_infoManagerCertState = { - .permissionName = "ohos.permission.ACCESS_CERT_MANAGER", - .isGeneral = true, - .resDeviceID = {"local3"}, - .grantStatus = {PermissionState::PERMISSION_DENIED}, - .grantFlags = {0} -}; - HapInfoParams g_testHapInfoParams = { .userID = 0, .bundleName = "UpdateHapTokenTest", @@ -86,11 +76,23 @@ HapInfoParams g_testHapInfoParams = { .appDistributionType = "" }; +PermissionDef g_permDef = { + .permissionName = "ohos.permission.test1", + .bundleName = "accesstoken_test", + .grantMode = 1, + .availableLevel = APL_NORMAL, + .label = "label3", + .labelId = 1, + .description = "open the door", + .descriptionId = 1, + .availableType = MDM +}; + HapPolicyParams g_testPolicyParams = { .apl = APL_SYSTEM_CORE, .domain = "test_domain", - .permList = {}, - .permStateList = { g_testPermReq }, + .permList = { g_permDef }, + .permStateList = { g_infoManagerCameraState, g_infoManagerMicrophoneState }, .aclRequestedList = {}, .preAuthorizationInfo = {} }; @@ -99,28 +101,50 @@ HapPolicyParams g_testPolicyParams = { void UpdateHapTokenTest::SetUpTestCase() { g_selfTokenId = GetSelfTokenID(); - // clean up test cases - AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_testHapInfoParams.userID, - g_testHapInfoParams.bundleName, - g_testHapInfoParams.instIndex); - AccessTokenKit::DeleteToken(tokenId); - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_testHapInfoParams, g_testPolicyParams); - SetSelfTokenID(tokenIdEx.tokenIDEx); + TestCommon::SetTestEvironment(g_selfTokenId); + + // native process with MANAGER_HAP_ID + g_mock = new (std::nothrow) MockNativeToken("foundation"); } void UpdateHapTokenTest::TearDownTestCase() { - AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_testHapInfoParams.userID, - g_testHapInfoParams.bundleName, - g_testHapInfoParams.instIndex); - AccessTokenKit::DeleteToken(tokenId); - SetSelfTokenID(g_selfTokenId); + AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenKit::DeleteToken(tokenID); + + tokenID = AccessTokenKit::GetHapTokenID( + g_testHapInfoParams.userID, g_testHapInfoParams.bundleName, g_testHapInfoParams.instIndex); + AccessTokenKit::DeleteToken(tokenID); + + if (g_mock != nullptr) { + delete g_mock; + g_mock = nullptr; + } + EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId)); + TestCommon::ResetTestEvironment(); } void UpdateHapTokenTest::SetUp() { LOGI(ATM_DOMAIN, ATM_TAG, "SetUp ok."); - setuid(0); + HapInfoParams info = { + .userID = TEST_USER_ID, + .bundleName = TEST_BUNDLE_NAME, + .instIndex = 0, + .appIDDesc = "appIDDesc", + .apiVersion = TestCommon::DEFAULT_API_VERSION + }; + + HapPolicyParams policy = { + .apl = APL_NORMAL, + .domain = "domain" + }; + policy.permStateList.emplace_back(g_infoManagerCameraState); + policy.permStateList.emplace_back(g_infoManagerMicrophoneState); + + AccessTokenIDEx tokenIdEx = {0}; + EXPECT_EQ(RET_SUCCESS, TestCommon::AllocTestHapToken(info, policy, tokenIdEx)); + ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); } void UpdateHapTokenTest::TearDown() @@ -143,9 +167,9 @@ HWTEST_F(UpdateHapTokenTest, UpdateHapTokenFuncTest001, TestSize.Level1) HapPolicyParams policyParams; TestCommon::GetHapParams(infoParams, policyParams); AccessTokenIDEx fullTokenId; - int32_t ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId)); AccessTokenID tokenID = fullTokenId.tokenIdExStruct.tokenID; - ASSERT_EQ(RET_SUCCESS, ret); + ASSERT_NE(INVALID_TOKENID, tokenID); UpdateHapInfoParams updateHapInfoParams = { .appIDDesc = "HapTokenTestAppID_1", .apiVersion = infoParams.apiVersion, @@ -153,8 +177,7 @@ HWTEST_F(UpdateHapTokenTest, UpdateHapTokenFuncTest001, TestSize.Level1) .appDistributionType = infoParams.appDistributionType }; - ret = AccessTokenKit::UpdateHapToken(fullTokenId, updateHapInfoParams, policyParams); - ASSERT_EQ(RET_SUCCESS, ret); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UpdateHapToken(fullTokenId, updateHapInfoParams, policyParams)); HapTokenInfo hapInfo; AccessTokenKit::GetHapTokenInfo(tokenID, hapInfo); @@ -168,6 +191,8 @@ HWTEST_F(UpdateHapTokenTest, UpdateHapTokenFuncTest001, TestSize.Level1) HapTokenInfoExt hapInfoExt; AccessTokenKit::GetHapTokenInfoExtension(tokenID, hapInfoExt); EXPECT_EQ("HapTokenTestAppID_1", hapInfoExt.appID); + + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); } /** @@ -186,9 +211,8 @@ HWTEST_F(UpdateHapTokenTest, UpdateHapTokenFuncTest002, TestSize.Level1) HapPolicyParams policyParams; TestCommon::GetHapParams(infoParams, policyParams); AccessTokenIDEx fullTokenId; - int32_t ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId)); AccessTokenID tokenID = fullTokenId.tokenIdExStruct.tokenID; - ASSERT_EQ(RET_SUCCESS, ret); UpdateHapInfoParams updateHapInfoParams = { .appIDDesc = infoParams.appIDDesc, .apiVersion = API_VERSION_EIGHT, @@ -196,8 +220,7 @@ HWTEST_F(UpdateHapTokenTest, UpdateHapTokenFuncTest002, TestSize.Level1) .appDistributionType = infoParams.appDistributionType }; - ret = AccessTokenKit::UpdateHapToken(fullTokenId, updateHapInfoParams, policyParams); - ASSERT_EQ(RET_SUCCESS, ret); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UpdateHapToken(fullTokenId, updateHapInfoParams, policyParams)); HapTokenInfo hapInfo; AccessTokenKit::GetHapTokenInfo(tokenID, hapInfo); @@ -211,6 +234,8 @@ HWTEST_F(UpdateHapTokenTest, UpdateHapTokenFuncTest002, TestSize.Level1) HapTokenInfoExt hapInfoExt; AccessTokenKit::GetHapTokenInfoExtension(tokenID, hapInfoExt); EXPECT_EQ("AccessTokenTestAppID", hapInfoExt.appID); + + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); } /** @@ -230,9 +255,8 @@ HWTEST_F(UpdateHapTokenTest, UpdateHapTokenFuncTest003, TestSize.Level1) HapPolicyParams policyParams; TestCommon::GetHapParams(infoParams, policyParams); AccessTokenIDEx fullTokenId; - int32_t ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId)); AccessTokenID tokenID = fullTokenId.tokenIdExStruct.tokenID; - ASSERT_EQ(RET_SUCCESS, ret); UpdateHapInfoParams updateHapInfoParams = { .appIDDesc = infoParams.appIDDesc, .apiVersion = infoParams.apiVersion, @@ -240,8 +264,7 @@ HWTEST_F(UpdateHapTokenTest, UpdateHapTokenFuncTest003, TestSize.Level1) .appDistributionType = infoParams.appDistributionType }; - ret = AccessTokenKit::UpdateHapToken(fullTokenId, updateHapInfoParams, policyParams); - ASSERT_EQ(RET_SUCCESS, ret); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UpdateHapToken(fullTokenId, updateHapInfoParams, policyParams)); HapTokenInfo hapInfo; AccessTokenKit::GetHapTokenInfo(tokenID, hapInfo); @@ -257,11 +280,12 @@ HWTEST_F(UpdateHapTokenTest, UpdateHapTokenFuncTest003, TestSize.Level1) EXPECT_EQ("AccessTokenTestAppID", hapInfoExt.appID); updateHapInfoParams.isSystemApp = true; - ret = AccessTokenKit::UpdateHapToken(fullTokenId, updateHapInfoParams, policyParams); - ASSERT_EQ(RET_SUCCESS, ret); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UpdateHapToken(fullTokenId, updateHapInfoParams, policyParams)); - AccessTokenKit::GetHapTokenInfo(tokenID, hapInfo); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GetHapTokenInfo(tokenID, hapInfo)); EXPECT_EQ(1, hapInfo.tokenAttr); + + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); } void GetPermissions(string permissionName, PermissionStateFull& stateFull, PreAuthorizationInfo& info) @@ -296,13 +320,10 @@ HWTEST_F(UpdateHapTokenTest, UpdateHapTokenFuncTest004, TestSize.Level1) TestCommon::GetHapParams(infoParams, policyParams); policyParams.apl = APL_SYSTEM_CORE; AccessTokenIDEx fullTokenId; - int32_t ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId)); AccessTokenID tokenID = fullTokenId.tokenIdExStruct.tokenID; - ASSERT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.RECEIVE_SMS"); - EXPECT_EQ(PERMISSION_DENIED, ret); - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.RECEIVE_MMS"); - EXPECT_EQ(PERMISSION_DENIED, ret); + EXPECT_EQ(PERMISSION_DENIED, AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.RECEIVE_SMS")); + EXPECT_EQ(PERMISSION_DENIED, AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.RECEIVE_MMS")); UpdateHapInfoParams updateHapInfoParams = { .appIDDesc = infoParams.appIDDesc, .apiVersion = infoParams.apiVersion, @@ -320,11 +341,9 @@ HWTEST_F(UpdateHapTokenTest, UpdateHapTokenFuncTest004, TestSize.Level1) policyParams.permStateList = {permissionStateFull001, permissionStateFull002}; policyParams.preAuthorizationInfo = {info1, info2}; - ret = AccessTokenKit::UpdateHapToken(fullTokenId, updateHapInfoParams, policyParams); - ASSERT_EQ(RET_SUCCESS, ret); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UpdateHapToken(fullTokenId, updateHapInfoParams, policyParams)); std::vector permStatList; - int32_t res = AccessTokenKit::GetReqPermissions(tokenID, permStatList, false); - ASSERT_EQ(RET_SUCCESS, res); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GetReqPermissions(tokenID, permStatList, false)); ASSERT_EQ(static_cast(2), permStatList.size()); ASSERT_EQ("ohos.permission.RECEIVE_SMS", permStatList[0].permissionName); EXPECT_EQ(permStatList[0].grantStatus[0], PERMISSION_GRANTED); @@ -332,6 +351,8 @@ HWTEST_F(UpdateHapTokenTest, UpdateHapTokenFuncTest004, TestSize.Level1) ASSERT_EQ("ohos.permission.RECEIVE_MMS", permStatList[1].permissionName); EXPECT_EQ(permStatList[1].grantStatus[0], PERMISSION_GRANTED); EXPECT_EQ(permStatList[1].grantFlags[0], PERMISSION_SYSTEM_FIXED); + + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); } /** @@ -367,14 +388,11 @@ HWTEST_F(UpdateHapTokenTest, UpdateHapTokenFuncTest005, TestSize.Level1) }; policyParams.permStateList = {permissionStateFull001, permissionStateFull002}; AccessTokenIDEx fullTokenId; - int32_t ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId)); AccessTokenID tokenID = fullTokenId.tokenIdExStruct.tokenID; - ASSERT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.RUN_DYN_CODE"); - EXPECT_EQ(PERMISSION_GRANTED, ret); - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.ACCESS_DDK_USB"); - EXPECT_EQ(PERMISSION_GRANTED, ret); + EXPECT_EQ(PERMISSION_GRANTED, AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.RUN_DYN_CODE")); + EXPECT_EQ(PERMISSION_GRANTED, AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.ACCESS_DDK_USB")); UpdateHapInfoParams updateHapInfoParams = { .appIDDesc = infoParams.appIDDesc, @@ -384,13 +402,12 @@ HWTEST_F(UpdateHapTokenTest, UpdateHapTokenFuncTest005, TestSize.Level1) }; policyParams.permStateList = {}; - ret = AccessTokenKit::UpdateHapToken(fullTokenId, updateHapInfoParams, policyParams); - ASSERT_EQ(RET_SUCCESS, ret); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UpdateHapToken(fullTokenId, updateHapInfoParams, policyParams)); - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.RUN_DYN_CODE"); - EXPECT_EQ(PERMISSION_DENIED, ret); - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.ACCESS_DDK_USB"); - EXPECT_EQ(PERMISSION_DENIED, ret); + EXPECT_EQ(PERMISSION_DENIED, AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.RUN_DYN_CODE")); + EXPECT_EQ(PERMISSION_DENIED, AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.ACCESS_DDK_USB")); + + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); } /** @@ -417,15 +434,14 @@ HWTEST_F(UpdateHapTokenTest, UpdateHapTokenFuncTest006, TestSize.Level1) }; policyParams.permStateList = {permissionStateFull001}; - AccessTokenIDEx fullTokenId; - int32_t ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); + AccessTokenIDEx fullTokenId = {0}; + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId)); AccessTokenID tokenID = fullTokenId.tokenIdExStruct.tokenID; - ASSERT_EQ(RET_SUCCESS, ret); + ASSERT_NE(INVALID_TOKENID, tokenID); - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.RUN_DYN_CODE"); - EXPECT_EQ(PERMISSION_GRANTED, ret); - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.ACCESS_EXTENSIONAL_DEVICE_DRIVER"); - EXPECT_EQ(PERMISSION_DENIED, ret); + EXPECT_EQ(PERMISSION_GRANTED, AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.RUN_DYN_CODE")); + EXPECT_EQ(PERMISSION_DENIED, + AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.ACCESS_EXTENSIONAL_DEVICE_DRIVER")); UpdateHapInfoParams updateHapInfoParams = { .appIDDesc = infoParams.appIDDesc, .apiVersion = infoParams.apiVersion, @@ -441,13 +457,341 @@ HWTEST_F(UpdateHapTokenTest, UpdateHapTokenFuncTest006, TestSize.Level1) }; policyParams.permStateList = { permissionStateFull003 }; - ret = AccessTokenKit::UpdateHapToken(fullTokenId, updateHapInfoParams, policyParams); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UpdateHapToken(fullTokenId, updateHapInfoParams, policyParams)); + + EXPECT_EQ(PERMISSION_DENIED, AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.RUN_DYN_CODE")); + EXPECT_EQ(PERMISSION_GRANTED, + AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.ACCESS_EXTENSIONAL_DEVICE_DRIVER")); + + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); +} + +static bool ExistInVector(vector array, unsigned int value) +{ + vector::iterator it = find(array.begin(), array.end(), value); + if (it != array.end()) { + return true; + } else { + return false; + } +} + +/** + * @tc.name: UpdateHapTokenFuncTest007 + * @tc.desc: update a batch of tokenId. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(UpdateHapTokenTest, UpdateHapTokenFuncTest007, TestSize.Level1) +{ + int allocFlag = 0; + int updateFlag = 0; + int deleteFlag = 0; + AccessTokenIDEx tokenIdEx = {0}; + vector obj; + bool exist; + HapInfoParams testInfo = g_testHapInfoParams; + HapPolicyParams testPolicy = g_testPolicyParams; + + for (int i = 0; i < CYCLE_TIMES; i++) { + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(testInfo, testPolicy, tokenIdEx)); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + + exist = ExistInVector(obj, tokenID); + if (exist) { + allocFlag = 1; + break; + } + obj.push_back(tokenID); + testInfo.userID++; + } + + testInfo.instIndex = 1; + testPolicy.apl = APL_SYSTEM_BASIC; + UpdateHapInfoParams info; + info.appIDDesc = g_testHapInfoParams.appIDDesc; + info.apiVersion = TestCommon::DEFAULT_API_VERSION; + info.appDistributionType = "enterprise_mdm"; + info.isSystemApp = false; + for (size_t i = 0; i < obj.size(); i++) { + AccessTokenIDEx idEx = { + .tokenIdExStruct.tokenID = obj[i], + .tokenIdExStruct.tokenAttr = 0, + }; + int ret = AccessTokenKit::UpdateHapToken(idEx, info, testPolicy); + if (RET_SUCCESS != ret) { + updateFlag = 1; + break; + } + } + testPolicy.apl = APL_NORMAL; + + for (size_t i = 0; i < obj.size(); i++) { + int ret = AccessTokenKit::DeleteToken(obj[i]); + if (RET_SUCCESS != ret) { + deleteFlag = 1; + } + } + ASSERT_EQ(allocFlag, 0); + ASSERT_EQ(updateFlag, 0); + ASSERT_EQ(deleteFlag, 0); +} + +/** + * @tc.name: UpdateHapTokenFuncTest008 + * @tc.desc: add new permissdef. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(UpdateHapTokenTest, UpdateHapTokenFuncTest008, TestSize.Level1) +{ + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(g_testHapInfoParams, g_testPolicyParams, tokenIdEx)); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + + PermissionDef permDefResult; + /* check permission define before update */ + int32_t ret = AccessTokenKit::GetDefPermission("ohos.permission.test3", permDefResult); + ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, ret); + + std::string backUp = g_testPolicyParams.permList[INDEX_ZERO].permissionName; + g_testPolicyParams.permList[INDEX_ZERO].permissionName = "ohos.permission.test3"; + UpdateHapInfoParams info; + info.appIDDesc = g_testHapInfoParams.appIDDesc; + info.apiVersion = TestCommon::DEFAULT_API_VERSION; + info.isSystemApp = false; + info.appDistributionType = "enterprise_mdm"; + ret = AccessTokenKit::UpdateHapToken(tokenIdEx, info, g_testPolicyParams); ASSERT_EQ(RET_SUCCESS, ret); + g_testPolicyParams.permList[INDEX_ZERO].permissionName = backUp; - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.RUN_DYN_CODE"); - EXPECT_EQ(PERMISSION_DENIED, ret); - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.ACCESS_EXTENSIONAL_DEVICE_DRIVER"); - EXPECT_EQ(PERMISSION_GRANTED, ret); + GTEST_LOG_(INFO) << "permissionName :" << g_testPolicyParams.permList[INDEX_ZERO].permissionName; + + ret = AccessTokenKit::GetDefPermission("ohos.permission.test3", permDefResult); + ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, ret); + ASSERT_NE("ohos.permission.test3", permDefResult.permissionName); + + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); +} +/** + * @tc.name: UpdateHapTokenFuncTest009 + * @tc.desc: modify permissdef's grantMode. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(UpdateHapTokenTest, UpdateHapTokenFuncTest009, TestSize.Level1) +{ + const std::string appIDDesc = g_testHapInfoParams.appIDDesc; + int backupMode = g_testPolicyParams.permList[INDEX_ZERO].grantMode; + std::string backupLable = g_testPolicyParams.permList[INDEX_ZERO].label; + + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(g_testHapInfoParams, g_testPolicyParams, tokenIdEx)); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + + PermissionDef permDefResult; + /* check permission define before update */ + int32_t ret = AccessTokenKit::GetDefPermission( + g_testPolicyParams.permList[INDEX_ZERO].permissionName, permDefResult); + ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, ret); + + g_testPolicyParams.permList[INDEX_ZERO].grantMode = 0; + g_testPolicyParams.permList[INDEX_ZERO].label = "updated label"; + UpdateHapInfoParams info; + info.appIDDesc = appIDDesc; + info.apiVersion = TestCommon::DEFAULT_API_VERSION; + info.isSystemApp = false; + info.appDistributionType = "enterprise_mdm"; + ret = AccessTokenKit::UpdateHapToken(tokenIdEx, info, g_testPolicyParams); + ASSERT_EQ(RET_SUCCESS, ret); + + /* check permission define after update */ + ret = AccessTokenKit::GetDefPermission( + g_testPolicyParams.permList[INDEX_ZERO].permissionName, permDefResult); + ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, ret); + + g_testPolicyParams.permList[INDEX_ZERO].label = backupLable; + g_testPolicyParams.permList[INDEX_ZERO].grantMode = backupMode; + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); +} + +/** + * @tc.name: UpdateHapTokenFuncTest010 + * @tc.desc: old permission will not update its grantStatus. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(UpdateHapTokenTest, UpdateHapTokenFuncTest010, TestSize.Level1) +{ + const std::string appIDDesc = g_testHapInfoParams.appIDDesc; + std::string permission = g_infoManagerCameraState.permissionName; + + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(g_testHapInfoParams, g_testPolicyParams, tokenIdEx)); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GrantPermission(tokenID, permission, PERMISSION_USER_FIXED)); + + ASSERT_EQ(PERMISSION_GRANTED, AccessTokenKit::VerifyAccessToken(tokenID, permission, false)); + + HapPolicyParams infoManagerTestPolicyPrams = { + .apl = APL_NORMAL, + .domain = "test.domain", + .permStateList = {g_infoManagerCameraState} + }; + UpdateHapInfoParams info; + info.appIDDesc = appIDDesc; + info.apiVersion = TestCommon::DEFAULT_API_VERSION; + info.isSystemApp = false; + info.appDistributionType = "enterprise_mdm"; + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UpdateHapToken(tokenIdEx, info, infoManagerTestPolicyPrams)); + + ASSERT_EQ(PERMISSION_GRANTED, AccessTokenKit::VerifyAccessToken(tokenID, permission, false)); + + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); +} + +/** + * @tc.name: UpdateHapTokenFuncTest011 + * @tc.desc: update api version. + * @tc.type: FUNC + * @tc.require:Issue Number + */ +HWTEST_F(UpdateHapTokenTest, UpdateHapTokenFuncTest011, TestSize.Level1) +{ + const std::string appIDDesc = g_testHapInfoParams.appIDDesc; + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(g_testHapInfoParams, g_testPolicyParams, tokenIdEx)); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + + UpdateHapInfoParams info; + info.appIDDesc = appIDDesc; + info.isSystemApp = false; + info.appDistributionType = "enterprise_mdm"; + + info.apiVersion = TestCommon::DEFAULT_API_VERSION - 1; + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UpdateHapToken(tokenIdEx, info, g_testPolicyParams)); + + HapTokenInfo hapTokenInfoRes; + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GetHapTokenInfo(tokenID, hapTokenInfoRes)); + ASSERT_EQ(info.apiVersion, hapTokenInfoRes.apiVersion); + + info.apiVersion = TestCommon::DEFAULT_API_VERSION + 1; + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UpdateHapToken(tokenIdEx, info, g_testPolicyParams)); + + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GetHapTokenInfo(tokenID, hapTokenInfoRes)); + ASSERT_EQ(info.apiVersion, hapTokenInfoRes.apiVersion); + + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); +} + +/** + * @tc.name: UpdateHapTokenFuncTest012 + * @tc.desc: AccessTokenKit::UpdateHapToken function test + * @tc.type: FUNC + * @tc.require: issueI61A6M + */ +HWTEST_F(UpdateHapTokenTest, UpdateHapTokenFuncTest012, TestSize.Level1) +{ + AccessTokenIDEx tokenID = {0}; + HapPolicyParams policy; + UpdateHapInfoParams info; + info.appIDDesc = std::string("updateFailed"); + info.apiVersion = 0; + info.isSystemApp = false; + ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, + AccessTokenKit::UpdateHapToken(tokenID, info, policy)); +} + +static void *ThreadTestFunc01(void *args) +{ + ATokenTypeEnum type; + AccessTokenID tokenID; + + for (int i = 0; i < CYCLE_TIMES; i++) { + tokenID = AccessTokenKit::AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + type = AccessTokenKit::GetTokenType(tokenID); + if (type != TOKEN_HAP) { + GTEST_LOG_(INFO) << "ThreadTestFunc01 failed" << tokenID; + } + } + return nullptr; +} + +static void *ThreadTestFunc02(void *args) +{ + int ret; + AccessTokenID tokenID; + HapTokenInfo hapTokenInfoRes; + + for (int i = 0; i < CYCLE_TIMES; i++) { + tokenID = AccessTokenKit::AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + ret = AccessTokenKit::GetHapTokenInfo(tokenID, hapTokenInfoRes); + if (ret != RET_SUCCESS) { + GTEST_LOG_(INFO) << "ThreadTestFunc02 failed" << tokenID; + } + } + return nullptr; +} + +/** + * @tc.name: AllocHapToken011 + * @tc.desc: Mulitpulthread test. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(UpdateHapTokenTest, Mulitpulthread001, TestSize.Level1) +{ + AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + ASSERT_NE(INVALID_TOKENID, tokenID); + pthread_t tid[2]; + (void)pthread_create(&tid[0], nullptr, &ThreadTestFunc01, nullptr); + (void)pthread_create(&tid[1], nullptr, &ThreadTestFunc01, nullptr); + (void)pthread_join(tid[0], nullptr); + (void)pthread_join(tid[1], nullptr); + + (void)pthread_create(&tid[0], nullptr, &ThreadTestFunc02, nullptr); + (void)pthread_create(&tid[1], nullptr, &ThreadTestFunc02, nullptr); + (void)pthread_join(tid[0], nullptr); + (void)pthread_join(tid[1], nullptr); +} + +void ConcurrencyTask(unsigned int tokenID) +{ + uint32_t flag; + for (int i = 0; i < CYCLE_TIMES; i++) { + AccessTokenKit::GrantPermission(tokenID, g_infoManagerMicrophoneState.permissionName, PERMISSION_USER_FIXED); + AccessTokenKit::GetPermissionFlag(tokenID, g_infoManagerMicrophoneState.permissionName, flag); + AccessTokenKit::VerifyAccessToken(tokenID, g_infoManagerMicrophoneState.permissionName, false); + + AccessTokenKit::RevokePermission(tokenID, g_infoManagerMicrophoneState.permissionName, PERMISSION_USER_SET); + AccessTokenKit::GetPermissionFlag(tokenID, g_infoManagerMicrophoneState.permissionName, flag); + AccessTokenKit::VerifyAccessToken(tokenID, g_infoManagerMicrophoneState.permissionName, false); + } +} + +/** + * @tc.name: ConcurrencyTest001 + * @tc.desc: Concurrency testing + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(UpdateHapTokenTest, ConcurrencyTest001, TestSize.Level1) +{ + AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + ASSERT_NE(INVALID_TOKENID, tokenID); + std::vector threadVec; + for (int i = 0; i < THREAD_NUM; i++) { + threadVec.emplace_back(std::thread(ConcurrencyTask, tokenID)); + } + for (auto it = threadVec.begin(); it != threadVec.end(); it++) { + it->join(); + } } /** @@ -483,12 +827,10 @@ HWTEST_F(UpdateHapTokenTest, UpdateHapTokenSpecsTest001, TestSize.Level1) }; policyParams.permStateList = {permissionStateFull001}; AccessTokenIDEx fullTokenId; - int32_t ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId)); AccessTokenID tokenID = fullTokenId.tokenIdExStruct.tokenID; - ASSERT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.RUN_DYN_CODE"); - EXPECT_EQ(PERMISSION_GRANTED, ret); + EXPECT_EQ(PERMISSION_GRANTED, AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.RUN_DYN_CODE")); UpdateHapInfoParams updateHapInfoParams = { .appIDDesc = infoParams.appIDDesc, @@ -498,14 +840,13 @@ HWTEST_F(UpdateHapTokenTest, UpdateHapTokenSpecsTest001, TestSize.Level1) }; policyParams.permStateList = {permissionStateFull001, permissionStateFull002}; policyParams.aclRequestedList = {"ohos.permission.ACCESS_DDK_USB"}; - ret = AccessTokenKit::UpdateHapToken(fullTokenId, updateHapInfoParams, policyParams); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UpdateHapToken(fullTokenId, updateHapInfoParams, policyParams)); tokenID = fullTokenId.tokenIdExStruct.tokenID; - ASSERT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.RUN_DYN_CODE"); - EXPECT_EQ(PERMISSION_GRANTED, ret); - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.ACCESS_DDK_USB"); - EXPECT_EQ(PERMISSION_GRANTED, ret); + EXPECT_EQ(PERMISSION_GRANTED, AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.RUN_DYN_CODE")); + EXPECT_EQ(PERMISSION_GRANTED, AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.ACCESS_DDK_USB")); + + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); } /** @@ -543,13 +884,10 @@ HWTEST_F(UpdateHapTokenTest, UpdateHapTokenSpecsTest002, TestSize.Level1) policyParams.permStateList = {permissionStateFull001, permissionStateFull002}; policyParams.aclRequestedList = {"ohos.permission.ACCESS_DDK_USB"}; AccessTokenIDEx fullTokenId; - int32_t ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId)); AccessTokenID tokenID = fullTokenId.tokenIdExStruct.tokenID; - ASSERT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.RUN_DYN_CODE"); - EXPECT_EQ(PERMISSION_GRANTED, ret); - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.ACCESS_DDK_USB"); - EXPECT_EQ(PERMISSION_GRANTED, ret); + EXPECT_EQ(PERMISSION_GRANTED, AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.RUN_DYN_CODE")); + EXPECT_EQ(PERMISSION_GRANTED, AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.ACCESS_DDK_USB")); UpdateHapInfoParams updateHapInfoParams = { .appIDDesc = infoParams.appIDDesc, @@ -558,9 +896,11 @@ HWTEST_F(UpdateHapTokenTest, UpdateHapTokenSpecsTest002, TestSize.Level1) .appDistributionType = infoParams.appDistributionType }; policyParams.aclRequestedList = {}; - ret = AccessTokenKit::UpdateHapToken(fullTokenId, updateHapInfoParams, policyParams); + ASSERT_EQ( + ERR_PERM_REQUEST_CFG_FAILED, AccessTokenKit::UpdateHapToken(fullTokenId, updateHapInfoParams, policyParams)); tokenID = fullTokenId.tokenIdExStruct.tokenID; - ASSERT_EQ(ERR_PERM_REQUEST_CFG_FAILED, ret); + + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); } /** @@ -597,13 +937,10 @@ HWTEST_F(UpdateHapTokenTest, UpdateHapTokenSpecsTest003, TestSize.Level1) policyParams.permStateList = {permissionStateFull001, permissionStateFull002}; AccessTokenIDEx fullTokenId; - int32_t ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId)); AccessTokenID tokenID = fullTokenId.tokenIdExStruct.tokenID; - ASSERT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.RUN_DYN_CODE"); - EXPECT_EQ(PERMISSION_GRANTED, ret); - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.ACCESS_DDK_USB"); - EXPECT_EQ(PERMISSION_GRANTED, ret); + EXPECT_EQ(PERMISSION_GRANTED, AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.RUN_DYN_CODE")); + EXPECT_EQ(PERMISSION_GRANTED, AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.ACCESS_DDK_USB")); UpdateHapInfoParams updateHapInfoParams = { .appIDDesc = infoParams.appIDDesc, @@ -612,9 +949,11 @@ HWTEST_F(UpdateHapTokenTest, UpdateHapTokenSpecsTest003, TestSize.Level1) .appDistributionType = infoParams.appDistributionType }; policyParams.apl = APL_NORMAL; - ret = AccessTokenKit::UpdateHapToken(fullTokenId, updateHapInfoParams, policyParams); + ASSERT_EQ( + ERR_PERM_REQUEST_CFG_FAILED, AccessTokenKit::UpdateHapToken(fullTokenId, updateHapInfoParams, policyParams)); tokenID = fullTokenId.tokenIdExStruct.tokenID; - ASSERT_EQ(ERR_PERM_REQUEST_CFG_FAILED, ret); + + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); } /** @@ -642,11 +981,10 @@ HWTEST_F(UpdateHapTokenTest, UpdateHapTokenSpecsTest004, TestSize.Level1) }; policyParams.permStateList = {permissionStateFull001}; AccessTokenIDEx fullTokenId; - int32_t ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId)); AccessTokenID tokenID = fullTokenId.tokenIdExStruct.tokenID; - ASSERT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.MANAGE_FINGERPRINT_AUTH"); - EXPECT_EQ(PERMISSION_GRANTED, ret); + EXPECT_EQ( + PERMISSION_GRANTED, AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.MANAGE_FINGERPRINT_AUTH")); UpdateHapInfoParams updateHapInfoParams = { .appIDDesc = infoParams.appIDDesc, @@ -655,12 +993,13 @@ HWTEST_F(UpdateHapTokenTest, UpdateHapTokenSpecsTest004, TestSize.Level1) .appDistributionType = APP_DISTRIBUTION_TYPE_ENTERPRISE_MDM }; - ret = AccessTokenKit::UpdateHapToken(fullTokenId, updateHapInfoParams, policyParams); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UpdateHapToken(fullTokenId, updateHapInfoParams, policyParams)); tokenID = fullTokenId.tokenIdExStruct.tokenID; - ASSERT_EQ(RET_SUCCESS, ret); // MDM Control not apply, verify result is PERMISSION_GRANTED - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.MANAGE_FINGERPRINT_AUTH"); - EXPECT_EQ(PERMISSION_GRANTED, ret); + EXPECT_EQ( + PERMISSION_GRANTED, AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.MANAGE_FINGERPRINT_AUTH")); + + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); } /** @@ -696,14 +1035,13 @@ HWTEST_F(UpdateHapTokenTest, UpdateHapTokenSpecsTest005, TestSize.Level1) }; policyParams.permStateList = {permissionStateFull001, permissionStateFull002}; AccessTokenIDEx fullTokenId; - int32_t ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId)); AccessTokenID tokenID = fullTokenId.tokenIdExStruct.tokenID; - ASSERT_EQ(RET_SUCCESS, ret); // MDM Control not apply, verify result is PERMISSION_GRANTED - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.ENTERPRISE_MANAGE_SETTINGS"); - EXPECT_EQ(PERMISSION_GRANTED, ret); - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.MANAGE_FINGERPRINT_AUTH"); - EXPECT_EQ(PERMISSION_GRANTED, ret); + EXPECT_EQ( + PERMISSION_GRANTED, AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.ENTERPRISE_MANAGE_SETTINGS")); + EXPECT_EQ( + PERMISSION_GRANTED, AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.MANAGE_FINGERPRINT_AUTH")); UpdateHapInfoParams updateHapInfoParams = { .appIDDesc = infoParams.appIDDesc, @@ -711,12 +1049,12 @@ HWTEST_F(UpdateHapTokenTest, UpdateHapTokenSpecsTest005, TestSize.Level1) .isSystemApp = false, .appDistributionType = "" }; - ret = AccessTokenKit::UpdateHapToken(fullTokenId, updateHapInfoParams, policyParams); - ASSERT_EQ(ERR_PERM_REQUEST_CFG_FAILED, ret); + ASSERT_EQ( + ERR_PERM_REQUEST_CFG_FAILED, AccessTokenKit::UpdateHapToken(fullTokenId, updateHapInfoParams, policyParams)); HapInfoCheckResult result; - ret = AccessTokenKit::UpdateHapToken(fullTokenId, updateHapInfoParams, policyParams, result); - ASSERT_EQ(ERR_PERM_REQUEST_CFG_FAILED, ret); + ASSERT_EQ(ERR_PERM_REQUEST_CFG_FAILED, + AccessTokenKit::UpdateHapToken(fullTokenId, updateHapInfoParams, policyParams, result)); ASSERT_EQ(result.permCheckResult.permissionName, "ohos.permission.ENTERPRISE_MANAGE_SETTINGS"); ASSERT_EQ(result.permCheckResult.rule, PERMISSION_EDM_RULE); ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); @@ -740,8 +1078,7 @@ HWTEST_F(UpdateHapTokenTest, UpdateHapTokenSpecsTest006, TestSize.Level1) .permStateList = {g_infoManagerCameraState} }; AccessTokenIDEx fullTokenId; - int32_t ret = AccessTokenKit::InitHapToken(g_testHapInfoParams, testPolicyParams1, fullTokenId); - EXPECT_EQ(RET_SUCCESS, ret); + EXPECT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(g_testHapInfoParams, testPolicyParams1, fullTokenId)); UpdateHapInfoParams info; info.appIDDesc = "TEST"; @@ -757,11 +1094,9 @@ HWTEST_F(UpdateHapTokenTest, UpdateHapTokenSpecsTest006, TestSize.Level1) .permStateList = {g_infoManagerCameraState}, .preAuthorizationInfo = {info1} }; - ret = AccessTokenKit::UpdateHapToken(fullTokenId, info, testPolicyParams2); - ASSERT_EQ(RET_SUCCESS, ret); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UpdateHapToken(fullTokenId, info, testPolicyParams2)); std::vector state; - int32_t res = AccessTokenKit::GetReqPermissions(fullTokenId.tokenIdExStruct.tokenID, state, false); - ASSERT_EQ(RET_SUCCESS, res); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GetReqPermissions(fullTokenId.tokenIdExStruct.tokenID, state, false)); ASSERT_EQ(static_cast(1), state.size()); ASSERT_EQ("ohos.permission.CAMERA", state[0].permissionName); EXPECT_EQ(state[0].grantStatus[0], PERMISSION_GRANTED); @@ -1040,9 +1375,6 @@ HWTEST_F(UpdateHapTokenTest, UpdateHapTokenSpecsTest011, TestSize.Level1) ret = AccessTokenKit::UpdateHapToken(fullTokenId, updateInfoParams, policyParams); ASSERT_EQ(RET_SUCCESS, ret); - // switch to shell token - SetSelfTokenID(g_selfTokenId); - std::vector kernelPermList; ret = AccessTokenKit::GetKernelPermissions(tokenID, kernelPermList); ASSERT_EQ(RET_SUCCESS, ret); @@ -1051,8 +1383,8 @@ HWTEST_F(UpdateHapTokenTest, UpdateHapTokenSpecsTest011, TestSize.Level1) std::string value; ret = AccessTokenKit::GetReqPermissionByName( tokenID, "ohos.permission.kernel.ALLOW_WRITABLE_CODE_MEMORY", value); - ASSERT_EQ(RET_SUCCESS, ret); - ASSERT_EQ("1", value); + ASSERT_NE(RET_SUCCESS, ret); + ASSERT_NE("1", value); ret = AccessTokenKit::GetReqPermissionByName( tokenID, "ohos.permission.kernel.ALLOW_EXECUTABLE_FORT_MEMORY", value); @@ -1064,9 +1396,7 @@ HWTEST_F(UpdateHapTokenTest, UpdateHapTokenSpecsTest011, TestSize.Level1) /** * @tc.name: UpdateHapTokenAbnormalTest001 - * @tc.desc: test invaild UpdateHapInfoParams.appIDDesc - * 1.appIDDesc is too long - * 2.update failed. + * @tc.desc: cannot update hap token info with invalid appIDDesc. * @tc.type: FUNC * @tc.require: */ @@ -1080,26 +1410,24 @@ HWTEST_F(UpdateHapTokenTest, UpdateHapTokenAbnormalTest001, TestSize.Level1) AccessTokenIDEx fullTokenId; int32_t ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); ASSERT_EQ(RET_SUCCESS, ret); + + const std::string appIDDesc (INVALID_APPIDDESC_LEN, 'x'); UpdateHapInfoParams updateHapInfoParams = { - .appIDDesc = infoParams.appIDDesc, + .appIDDesc = appIDDesc, .apiVersion = infoParams.apiVersion, .isSystemApp = infoParams.isSystemApp, .appDistributionType = infoParams.appDistributionType }; - for (int i = 0; i < THIRTY_TIME_CYCLES; i++) { - updateHapInfoParams.appIDDesc += OVER_SIZE_STR; - } - ret = AccessTokenKit::UpdateHapToken(fullTokenId, updateHapInfoParams, policyParams); EXPECT_EQ(ERR_PARAM_INVALID, ret); + + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(fullTokenId.tokenIdExStruct.tokenID)); } /** * @tc.name: UpdateHapTokenAbnormalTest002 - * @tc.desc: test invaild HapPolicyParams.apl - * 1.apl is invaild. - * 2.update failed. + * @tc.desc: cannot update a tokenId with invalid apl. * @tc.type: FUNC * @tc.require: */ @@ -1128,58 +1456,67 @@ HWTEST_F(UpdateHapTokenTest, UpdateHapTokenAbnormalTest002, TestSize.Level1) policyParams.apl = APL_ENUM_BUTT; ret = AccessTokenKit::UpdateHapToken(fullTokenId, updateHapInfoParams, policyParams); EXPECT_EQ(ERR_PARAM_INVALID, ret); + + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(fullTokenId.tokenIdExStruct.tokenID)); } /** * @tc.name: UpdateHapTokenAbnormalTest003 - * @tc.desc: test invaild permStateList.permissionName - * 1.permissionName is empty. - * 2.permissionName is invaild. - * 3.update success, GetReqPermissions is empty. + * @tc.desc: cannot update a tokenId with invalid string value. * @tc.type: FUNC * @tc.require: */ HWTEST_F(UpdateHapTokenTest, UpdateHapTokenAbnormalTest003, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "UpdateHapTokenAbnormalTest003"); + std::string backUpPermission = g_testPolicyParams.permList[INDEX_ZERO].permissionName; + PermissionDef permDefResult; - HapInfoParams infoParams; - HapPolicyParams policyParams; - TestCommon::GetHapParams(infoParams, policyParams); - AccessTokenIDEx fullTokenId; - int32_t ret = AccessTokenKit::InitHapToken(infoParams, policyParams, fullTokenId); - AccessTokenID tokenID = fullTokenId.tokenIdExStruct.tokenID; - ASSERT_EQ(RET_SUCCESS, ret); + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::InitHapToken(g_testHapInfoParams, g_testPolicyParams, tokenIdEx)); + ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIdExStruct.tokenID); - UpdateHapInfoParams updateHapInfoParams = { - .appIDDesc = infoParams.appIDDesc, - .apiVersion = infoParams.apiVersion, - .isSystemApp = infoParams.isSystemApp, - .appDistributionType = infoParams.appDistributionType - }; - - PermissionStateFull permissionStateFull001 = { - .permissionName = "", - .isGeneral = true, - .resDeviceID = {"local"}, - .grantStatus = {PERMISSION_DENIED}, - .grantFlags = {PERMISSION_SYSTEM_FIXED} - }; - PermissionStateFull permissionStateFull002 = { - .permissionName = "ohos.permission.test", - .isGeneral = true, - .resDeviceID = {"local"}, - .grantStatus = {PERMISSION_DENIED}, - .grantFlags = {PERMISSION_SYSTEM_FIXED} - }; - policyParams.permStateList.emplace_back(permissionStateFull001); - policyParams.permStateList.emplace_back(permissionStateFull002); - ret = AccessTokenKit::UpdateHapToken(fullTokenId, updateHapInfoParams, policyParams); - ASSERT_EQ(RET_SUCCESS, ret); - tokenID = fullTokenId.tokenIdExStruct.tokenID; - std::vector reqPermList; - ret = AccessTokenKit::GetReqPermissions(tokenID, reqPermList, false); - EXPECT_TRUE(reqPermList.empty()); + UpdateHapInfoParams info; + info.appIDDesc = g_testHapInfoParams.appIDDesc; + info.apiVersion = TestCommon::DEFAULT_API_VERSION; + info.appDistributionType = "enterprise_mdm"; + info.isSystemApp = false; + + std::string backup = g_testPolicyParams.permList[INDEX_ZERO].permissionName; + g_testPolicyParams.permList[INDEX_ZERO].permissionName = ""; + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UpdateHapToken(tokenIdEx, info, g_testPolicyParams)); + ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, + AccessTokenKit::GetDefPermission(g_testPolicyParams.permList[INDEX_ZERO].permissionName, permDefResult)); + g_testPolicyParams.permList[INDEX_ZERO].permissionName = backup; + + g_testPolicyParams.permList[INDEX_ZERO].permissionName = "ohos.permission.testtmp11"; + backup = g_testPolicyParams.permList[INDEX_ZERO].bundleName; + g_testPolicyParams.permList[INDEX_ZERO].bundleName = ""; + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UpdateHapToken(tokenIdEx, info, g_testPolicyParams)); + ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, + AccessTokenKit::GetDefPermission(g_testPolicyParams.permList[INDEX_ZERO].permissionName, permDefResult)); + g_testPolicyParams.permList[INDEX_ZERO].bundleName = backup; + g_testPolicyParams.permList[INDEX_ZERO].permissionName = backUpPermission; + + g_testPolicyParams.permList[INDEX_ZERO].permissionName = "ohos.permission.testtmp12"; + backup = g_testPolicyParams.permList[INDEX_ZERO].label; + g_testPolicyParams.permList[INDEX_ZERO].label = ""; + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UpdateHapToken(tokenIdEx, info, g_testPolicyParams)); + ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, + AccessTokenKit::GetDefPermission(g_testPolicyParams.permList[INDEX_ZERO].permissionName, permDefResult)); + g_testPolicyParams.permList[INDEX_ZERO].label = backup; + g_testPolicyParams.permList[INDEX_ZERO].permissionName = backUpPermission; + + g_testPolicyParams.permList[INDEX_ZERO].permissionName = "ohos.permission.testtmp13"; + backup = g_testPolicyParams.permList[INDEX_ZERO].description; + g_testPolicyParams.permList[INDEX_ZERO].description = ""; + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UpdateHapToken(tokenIdEx, info, g_testPolicyParams)); + ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, + AccessTokenKit::GetDefPermission(g_testPolicyParams.permList[INDEX_ZERO].permissionName, permDefResult)); + g_testPolicyParams.permList[INDEX_ZERO].description = backup; + g_testPolicyParams.permList[INDEX_ZERO].permissionName = backUpPermission; + + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenIdEx.tokenIdExStruct.tokenID)); } /** @@ -1243,6 +1580,8 @@ HWTEST_F(UpdateHapTokenTest, UpdateHapTokenAbnormalTest004, TestSize.Level1) ASSERT_EQ(ERR_PERM_REQUEST_CFG_FAILED, AccessTokenKit::UpdateHapToken(fullTokenId, updateHapInfoParams, policyParams)); + + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); } /** @@ -1294,6 +1633,29 @@ HWTEST_F(UpdateHapTokenTest, UpdateHapTokenAbnormalTest005, TestSize.Level1) ASSERT_EQ(RET_SUCCESS, ret); ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.AGENT_REQUIRE_FORM"); EXPECT_EQ(PERMISSION_DENIED, ret); + + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); +} + +/** + * @tc.name: UpdateHapTokenAbnormalTest005 + * @tc.desc: cannot update hap token info with invalid userId. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(UpdateHapTokenTest, UpdateHapTokenAbnormalTest006, TestSize.Level1) +{ + AccessTokenIDEx tokenIdEx = { + .tokenIdExStruct.tokenID = INVALID_TOKENID, + .tokenIdExStruct.tokenAttr = 0, + }; + UpdateHapInfoParams info; + info.appIDDesc = "appIDDesc"; + info.apiVersion = TestCommon::DEFAULT_API_VERSION; + info.isSystemApp = false; + int ret = AccessTokenKit::UpdateHapToken( + tokenIdEx, info, g_testPolicyParams); + ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); } } // namespace AccessToken } // namespace Security diff --git a/interfaces/innerkits/accesstoken/test/unittest/PermDenyTest/accesstoken_deny_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/PermDenyTest/accesstoken_deny_test.cpp index ddffa941fdaea958a7a23cf451056a9839de7f52..d1f8e22229eaf8209db4c7a022701273acba0206 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/PermDenyTest/accesstoken_deny_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/PermDenyTest/accesstoken_deny_test.cpp @@ -16,6 +16,7 @@ #include "accesstoken_deny_test.h" #include "accesstoken_kit.h" #include "access_token_error.h" +#include "test_common.h" #include "token_setproc.h" #ifdef TOKEN_SYNC_ENABLE #include "token_sync_kit_interface.h" @@ -25,7 +26,7 @@ namespace OHOS { namespace Security { namespace AccessToken { namespace { -static AccessTokenID g_selfTokenId = 0; +static uint64_t g_selfTokenId = 0; static AccessTokenIDEx g_testTokenIDEx = {0}; static int32_t g_selfUid; @@ -68,24 +69,20 @@ void AccessTokenDenyTest::SetUpTestCase() { g_selfTokenId = GetSelfTokenID(); g_selfUid = getuid(); + TestCommon::SetTestEvironment(g_selfTokenId); } void AccessTokenDenyTest::TearDownTestCase() { setuid(g_selfUid); EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId)); + TestCommon::ResetTestEvironment(); GTEST_LOG_(INFO) << "PermStateChangeCallback, tokenID is " << GetSelfTokenID(); GTEST_LOG_(INFO) << "PermStateChangeCallback, uid is " << getuid(); } void AccessTokenDenyTest::SetUp() { - AccessTokenKit::AllocHapToken(g_InfoParms, g_PolicyPrams); - - g_testTokenIDEx = AccessTokenKit::GetHapTokenIDEx(g_InfoParms.userID, - g_InfoParms.bundleName, - g_InfoParms.instIndex); - ASSERT_NE(INVALID_TOKENID, g_testTokenIDEx.tokenIDEx); setuid(g_selfUid); EXPECT_EQ(0, SetSelfTokenID(g_testTokenIDEx.tokenIDEx)); setuid(1234); // 1234: UID @@ -95,7 +92,6 @@ void AccessTokenDenyTest::TearDown() { setuid(g_selfUid); EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId)); - setuid(g_selfUid); } /** @@ -240,6 +236,22 @@ HWTEST_F(AccessTokenDenyTest, GetNativeTokenInfo001, TestSize.Level1) ASSERT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, AccessTokenKit::GetNativeTokenInfo(tokenId, tokenInfo)); } +/** + * @tc.name: GetReqPermissions001 + * @tc.desc: GetReqPermissions with no permission + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AccessTokenDenyTest, GetReqPermissions001, TestSize.Level1) +{ + std::vector permStatList; + AccessTokenID tokenID = 123; // 123: tokenid + + // no permission + ASSERT_EQ( + AccessTokenError::ERR_PERMISSION_DENIED, AccessTokenKit::GetReqPermissions(tokenID, permStatList, false)); +} + /** * @tc.name: GetPermissionFlag001 * @tc.desc: GetPermissionFlag with no permission @@ -294,7 +306,7 @@ HWTEST_F(AccessTokenDenyTest, GetPermissionRequestToggleStatus001, TestSize.Leve */ HWTEST_F(AccessTokenDenyTest, GrantPermission001, TestSize.Level1) { - AccessTokenID tokenId = 123; + AccessTokenID tokenId = 123; // 123: tokenid std::string permission = "ohos.permission.CAMERA"; ASSERT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, AccessTokenKit::GrantPermission(tokenId, permission, PERMISSION_USER_FIXED)); @@ -374,12 +386,13 @@ HWTEST_F(AccessTokenDenyTest, UnregisterPermStateChangeCallback001, TestSize.Lev HapPolicyParams policyPrams = { .apl = APL_NORMAL, .domain = "test.domain", - .permList = {}, - .permStateList = {testState} + .permStateList = {testState}, + .aclRequestedList = {"ohos.permission.GET_SENSITIVE_PERMISSIONS"} }; - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_InfoParms, policyPrams); + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ(RET_SUCCESS, TestCommon::AllocTestHapToken(g_InfoParms, policyPrams, tokenIdEx)); ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIdExStruct.tokenID); - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); + EXPECT_EQ(RET_SUCCESS, SetSelfTokenID(tokenIdEx.tokenIDEx)); PermStateChangeScope scopeInfo; scopeInfo.permList = {"ohos.permission.CAMERA"}; @@ -387,17 +400,18 @@ HWTEST_F(AccessTokenDenyTest, UnregisterPermStateChangeCallback001, TestSize.Lev auto callbackPtr = std::make_shared(scopeInfo); ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr)); - EXPECT_EQ(0, SetSelfTokenID(g_testTokenIDEx.tokenIDEx)); + EXPECT_EQ(RET_SUCCESS, SetSelfTokenID(g_testTokenIDEx.tokenIDEx)); ASSERT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr)); - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); + EXPECT_EQ(RET_SUCCESS, SetSelfTokenID(tokenIdEx.tokenIDEx)); ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr)); setuid(g_selfUid); - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenIdEx.tokenIdExStruct.tokenID)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID)); } +#ifndef ATM_BUILD_VARIANT_USER_ENABLE /** * @tc.name: ReloadNativeTokenInfo001 * @tc.desc: ReloadNativeTokenInfo with no permission @@ -408,6 +422,7 @@ HWTEST_F(AccessTokenDenyTest, ReloadNativeTokenInfo001, TestSize.Level1) { ASSERT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, AccessTokenKit::ReloadNativeTokenInfo()); } +#endif /** * @tc.name: GetNativeTokenId001 @@ -536,6 +551,19 @@ HWTEST_F(AccessTokenDenyTest, GrantPermissionForSpecifiedTime001, TestSize.Level ASSERT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, AccessTokenKit::GrantPermissionForSpecifiedTime(tokenId, permission, onceTime)); } + +/** + * @tc.name: GetKernelPermissions001 + * @tc.desc: GetKernelPermissions with permission denied + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AccessTokenDenyTest, GetKernelPermissions001, TestSize.Level1) +{ + AccessTokenID tokenId = 123; + std::vector kernelPermList; + ASSERT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, AccessTokenKit::GetKernelPermissions(tokenId, kernelPermList)); +} } // namespace AccessToken } // namespace Security } // namespace OHOS diff --git a/interfaces/innerkits/accesstoken/test/unittest/src/accesstoken_location_request_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/PermisionDialogTest/accesstoken_location_request_test.cpp similarity index 90% rename from interfaces/innerkits/accesstoken/test/unittest/src/accesstoken_location_request_test.cpp rename to interfaces/innerkits/accesstoken/test/unittest/PermisionDialogTest/accesstoken_location_request_test.cpp index 2cae73f64953a67f78c8b51e664e0b4e2569cf7d..faaf9209ad2d3f08d9dd5d109554c56deffc679f 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/src/accesstoken_location_request_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/PermisionDialogTest/accesstoken_location_request_test.cpp @@ -22,6 +22,7 @@ #include "permission_grant_info.h" #include "permission_list_state.h" #include "permission_state_full.h" +#include "test_common.h" #include "token_setproc.h" using namespace testing::ext; @@ -30,6 +31,7 @@ namespace OHOS { namespace Security { namespace AccessToken { namespace { +static uint64_t g_selfTokenId = 0; static constexpr int32_t TEST_USER_ID = 100; static std::string TEST_BUNDLE_NAME = "accesstoken_location_request_test"; static constexpr int32_t TEST_INST_INDEX = 0; @@ -121,25 +123,32 @@ PermissionStateFull g_locationTestStateBack12 = { void AccessTokenLocationRequestTest::SetUpTestCase() { - setuid(0); - AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, TEST_INST_INDEX); - AccessTokenKit::DeleteToken(tokenId); + g_selfTokenId = GetSelfTokenID(); + TestCommon::SetTestEvironment(g_selfTokenId); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID; + if (tokenId != INVALID_TOKENID) { + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenId)); + } } void AccessTokenLocationRequestTest::TearDownTestCase() { + SetSelfTokenID(g_selfTokenId); + TestCommon::ResetTestEvironment(); } void AccessTokenLocationRequestTest::SetUp() { - selfTokenId_ = GetSelfTokenID(); } void AccessTokenLocationRequestTest::TearDown() { - AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, TEST_INST_INDEX); - AccessTokenKit::DeleteToken(tokenId); - SetSelfTokenID(selfTokenId_); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID; + if (tokenId != INVALID_TOKENID) { + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenId)); + } } AccessTokenIDEx AllocHapToken(std::vector& permissionStateFulls, int32_t apiVersion) @@ -158,11 +167,33 @@ AccessTokenIDEx AllocHapToken(std::vector& permissionStateF .domain = "domain" }; - for (auto& permissionStateFull:permissionStateFulls) { + for (const auto& permissionStateFull : permissionStateFulls) { + PermissionDef permDefResult; + if (AccessTokenKit::GetDefPermission(permissionStateFull.permissionName, permDefResult) != RET_SUCCESS) { + continue; + } policy.permStateList.emplace_back(permissionStateFull); + if (permDefResult.availableLevel > policy.apl) { + policy.aclRequestedList.emplace_back(permissionStateFull.permissionName); + } } - return AccessTokenKit::AllocHapToken(info, policy); + AccessTokenIDEx tokenIdEx = {0}; + EXPECT_EQ(RET_SUCCESS, TestCommon::AllocTestHapToken(info, policy, tokenIdEx)); + AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID; + EXPECT_NE(tokenId, INVALID_TOKENID); + EXPECT_EQ(RET_SUCCESS, SetSelfTokenID(tokenIdEx.tokenIDEx)); + + for (const auto& permissionStateFull : permissionStateFulls) { + if (permissionStateFull.grantStatus[0] == PERMISSION_GRANTED) { + TestCommon::GrantPermissionByTest( + tokenId, permissionStateFull.permissionName, permissionStateFull.grantFlags[0]); + } else { + TestCommon::RevokePermissionByTest( + tokenId, permissionStateFull.permissionName, permissionStateFull.grantFlags[0]); + } + } + return tokenIdEx; } /** @@ -225,6 +256,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState002, TestSize.Le ASSERT_EQ(PASS_OPER, ret); ASSERT_EQ(static_cast(1), permsList2.size()); ASSERT_EQ(SETTING_OPER, permsList2[0].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -256,6 +290,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState003, TestSize.Le ASSERT_EQ(PASS_OPER, ret); ASSERT_EQ(static_cast(1), permsList3.size()); ASSERT_EQ(PASS_OPER, permsList3[0].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -287,6 +324,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState004, TestSize.Le ASSERT_EQ(PASS_OPER, ret); ASSERT_EQ(static_cast(1), permsList4.size()); ASSERT_EQ(INVALID_OPER, permsList4[0].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -319,6 +359,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState005, TestSize.Le ASSERT_EQ(DYNAMIC_OPER, ret); ASSERT_EQ(static_cast(1), permsList5.size()); ASSERT_EQ(DYNAMIC_OPER, permsList5[0].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -350,6 +393,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState006, TestSize.Le ASSERT_EQ(PASS_OPER, ret); ASSERT_EQ(static_cast(1), permsList6.size()); ASSERT_EQ(INVALID_OPER, permsList6[0].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -382,6 +428,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState007, TestSize.Le ASSERT_EQ(PASS_OPER, ret); ASSERT_EQ(static_cast(1), permsList7.size()); ASSERT_EQ(INVALID_OPER, permsList7[0].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -420,6 +469,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState008, TestSize.Le ASSERT_EQ(static_cast(2), permsList8.size()); ASSERT_EQ(DYNAMIC_OPER, permsList8[0].state); ASSERT_EQ(DYNAMIC_OPER, permsList8[1].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -453,11 +505,13 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState009, TestSize.Le permsList9.emplace_back(permAccurate9); PermissionGrantInfo info; - PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList9, info); - ASSERT_EQ(DYNAMIC_OPER, ret); + ASSERT_EQ(DYNAMIC_OPER, AccessTokenKit::GetSelfPermissionsState(permsList9, info)); ASSERT_EQ(static_cast(2), permsList9.size()); ASSERT_EQ(PASS_OPER, permsList9[0].state); ASSERT_EQ(DYNAMIC_OPER, permsList9[1].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -496,6 +550,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState010, TestSize.Le ASSERT_EQ(static_cast(2), permsList10.size()); ASSERT_EQ(SETTING_OPER, permsList10[0].state); ASSERT_EQ(INVALID_OPER, permsList10[1].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -534,6 +591,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState011, TestSize.Le ASSERT_EQ(static_cast(2), permsList11.size()); ASSERT_EQ(PASS_OPER, permsList11[0].state); ASSERT_EQ(PASS_OPER, permsList11[1].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -574,7 +634,7 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState012, TestSize.Le ASSERT_EQ(INVALID_OPER, permsList12[1].state); // grant back permission, get vague again, ret: DYNAMIC_OPER, state: DYNAMIC_OPER - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GrantPermission( + ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest( tokenID, "ohos.permission.LOCATION_IN_BACKGROUND", PermissionFlag::PERMISSION_USER_FIXED)); std::vector permsList121; permsList121.emplace_back(permVague12); @@ -582,6 +642,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState012, TestSize.Le ASSERT_EQ(DYNAMIC_OPER, ret); ASSERT_EQ(static_cast(1), permsList121.size()); ASSERT_EQ(DYNAMIC_OPER, permsList121[0].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -621,7 +684,7 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState013, TestSize.Le ASSERT_EQ(INVALID_OPER, permsList13[0].state); ASSERT_EQ(INVALID_OPER, permsList13[1].state); // grant back permission, get vague again, ret: PASS_OPER, state: PASS_OPER - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GrantPermission( + ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest( tokenID, "ohos.permission.LOCATION_IN_BACKGROUND", PermissionFlag::PERMISSION_USER_FIXED)); std::vector permsList131; permsList131.emplace_back(permVague13); @@ -629,6 +692,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState013, TestSize.Le ASSERT_EQ(PASS_OPER, ret); ASSERT_EQ(static_cast(1), permsList131.size()); ASSERT_EQ(PASS_OPER, permsList131[0].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -668,7 +734,7 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState014, TestSize.Le ASSERT_EQ(INVALID_OPER, permsList14[0].state); ASSERT_EQ(INVALID_OPER, permsList14[1].state); // grant back permission, get vague again, ret: PASS_OPER, state: SETTING_OPER - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GrantPermission( + ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest( tokenID, "ohos.permission.LOCATION_IN_BACKGROUND", PermissionFlag::PERMISSION_USER_FIXED)); std::vector permsList141; permsList141.emplace_back(permVague14); @@ -676,6 +742,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState014, TestSize.Le ASSERT_EQ(PASS_OPER, ret); ASSERT_EQ(static_cast(1), permsList141.size()); ASSERT_EQ(SETTING_OPER, permsList141[0].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -715,7 +784,7 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState015, TestSize.Le ASSERT_EQ(INVALID_OPER, permsList15[0].state); ASSERT_EQ(INVALID_OPER, permsList15[1].state); // grant back permission, get vague again, ret: PASS_OPER, state: PASS_OPER - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GrantPermission( + ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest( tokenID, "ohos.permission.LOCATION_IN_BACKGROUND", PermissionFlag::PERMISSION_USER_FIXED)); std::vector permsList151; permsList151.emplace_back(permVague15); @@ -723,6 +792,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState015, TestSize.Le ASSERT_EQ(PASS_OPER, ret); ASSERT_EQ(static_cast(1), permsList151.size()); ASSERT_EQ(PASS_OPER, permsList151[0].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -763,7 +835,7 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState016, TestSize.Le ASSERT_EQ(INVALID_OPER, permsList16[1].state); // grant back permission, get accerate again, ret: PASS_OPER, state: INVALID_OPER - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GrantPermission( + ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest( tokenID, "ohos.permission.LOCATION_IN_BACKGROUND", PermissionFlag::PERMISSION_USER_FIXED)); std::vector permsList161; permsList161.emplace_back(permAccurate16); @@ -771,6 +843,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState016, TestSize.Le ASSERT_EQ(PASS_OPER, ret); ASSERT_EQ(static_cast(1), permsList161.size()); ASSERT_EQ(INVALID_OPER, permsList161[0].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -812,7 +887,7 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState017, TestSize.Le ASSERT_EQ(INVALID_OPER, permsList17[1].state); // grant back permission, get accerate again, ret: PASS_OPER, state: INVALID_OPER - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GrantPermission( + ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest( tokenID, "ohos.permission.LOCATION_IN_BACKGROUND", PermissionFlag::PERMISSION_USER_FIXED)); std::vector permsList171; permsList171.emplace_back(permAccurate17); @@ -820,6 +895,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState017, TestSize.Le ASSERT_EQ(DYNAMIC_OPER, ret); // API>=11, only request accrtate, need pop dialog ASSERT_EQ(static_cast(1), permsList171.size()); ASSERT_EQ(DYNAMIC_OPER, permsList171[0].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -867,7 +945,7 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState018, TestSize.Le ASSERT_EQ(INVALID_OPER, permsList18[2].state); // grant back permission, get accerate&vague again, ret: DYNAMIC_OPER, state: DYNAMIC_OPER - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GrantPermission( + ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest( tokenID, "ohos.permission.LOCATION_IN_BACKGROUND", PermissionFlag::PERMISSION_USER_FIXED)); std::vector permsList181; permsList181.emplace_back(permVague18); @@ -877,6 +955,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState018, TestSize.Le ASSERT_EQ(static_cast(2), permsList181.size()); ASSERT_EQ(DYNAMIC_OPER, permsList181[0].state); ASSERT_EQ(DYNAMIC_OPER, permsList181[1].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -924,7 +1005,7 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState019, TestSize.Le ASSERT_EQ(INVALID_OPER, permsList19[2].state); // grant back permission, get accerate&vague again, ret: DYNAMIC_OPER, state: PASS_OPER + DYNAMIC_OPER - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GrantPermission( + ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest( tokenID, "ohos.permission.LOCATION_IN_BACKGROUND", PermissionFlag::PERMISSION_USER_FIXED)); std::vector permsList191; permsList191.emplace_back(permVague19); @@ -934,6 +1015,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState019, TestSize.Le ASSERT_EQ(static_cast(2), permsList191.size()); ASSERT_EQ(PASS_OPER, permsList191[0].state); ASSERT_EQ(DYNAMIC_OPER, permsList191[1].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -981,7 +1065,7 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState020, TestSize.Le ASSERT_EQ(INVALID_OPER, permsList20[2].state); // grant back permission, get accerate&vague again, ret: PASS_OPER, state: PASS_OPER + PASS_OPER - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GrantPermission( + ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest( tokenID, "ohos.permission.LOCATION_IN_BACKGROUND", PermissionFlag::PERMISSION_USER_FIXED)); std::vector permsList201; permsList201.emplace_back(permVague20); @@ -991,6 +1075,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState020, TestSize.Le ASSERT_EQ(static_cast(2), permsList201.size()); ASSERT_EQ(PASS_OPER, permsList201[0].state); ASSERT_EQ(PASS_OPER, permsList201[1].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -1046,6 +1133,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState021, TestSize.Le ASSERT_EQ(static_cast(2), permsList211.size()); ASSERT_EQ(PASS_OPER, permsList211[0].state); ASSERT_EQ(DYNAMIC_OPER, permsList211[1].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -1101,6 +1191,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState022, TestSize.Le ASSERT_EQ(static_cast(2), permsList221.size()); ASSERT_EQ(PASS_OPER, permsList221[0].state); ASSERT_EQ(PASS_OPER, permsList221[1].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -1147,7 +1240,7 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState023, TestSize.Le ASSERT_EQ(INVALID_OPER, permsList23[1].state); ASSERT_EQ(INVALID_OPER, permsList23[2].state); // grant back permission, get accerate&vague again, ret: PASS_OPER, state: SETTING_OPER + INVALID_OPER - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GrantPermission( + ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest( tokenID, "ohos.permission.LOCATION_IN_BACKGROUND", PermissionFlag::PERMISSION_USER_FIXED)); std::vector permsList231; permsList231.emplace_back(permVague23); @@ -1157,6 +1250,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState023, TestSize.Le ASSERT_EQ(static_cast(2), permsList231.size()); ASSERT_EQ(SETTING_OPER, permsList231[0].state); ASSERT_EQ(INVALID_OPER, permsList231[1].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -1196,33 +1292,33 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState024, TestSize.Le permsList24.emplace_back(permBack24); PermissionGrantInfo info; - PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList24, info); - ASSERT_EQ(PASS_OPER, ret); + ASSERT_EQ(PASS_OPER, AccessTokenKit::GetSelfPermissionsState(permsList24, info)); ASSERT_EQ(static_cast(3), permsList24.size()); ASSERT_EQ(INVALID_OPER, permsList24[0].state); ASSERT_EQ(INVALID_OPER, permsList24[1].state); ASSERT_EQ(INVALID_OPER, permsList24[2].state); // grant back permission, get accerate&vague again, ret: PASS_OPER, state: SETTING_OPER + SETTING_OPER - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GrantPermission( + ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest( tokenID, "ohos.permission.LOCATION_IN_BACKGROUND", PermissionFlag::PERMISSION_USER_FIXED)); std::vector permsList241; permsList241.emplace_back(permVague24); permsList241.emplace_back(permAccurate24); - ret = AccessTokenKit::GetSelfPermissionsState(permsList241, info); - ASSERT_EQ(PASS_OPER, ret); + ASSERT_EQ(PASS_OPER, AccessTokenKit::GetSelfPermissionsState(permsList241, info)); ASSERT_EQ(static_cast(2), permsList241.size()); ASSERT_EQ(SETTING_OPER, permsList241[0].state); ASSERT_EQ(SETTING_OPER, permsList241[1].state); // grant vague permission, get accerate&vague again, ret: PASS_OPER, state: PASS_OPER + SETTING_OPER - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GrantPermission( + ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest( tokenID, "ohos.permission.APPROXIMATELY_LOCATION", PermissionFlag::PERMISSION_USER_FIXED)); - ret = AccessTokenKit::GetSelfPermissionsState(permsList241, info); - ASSERT_EQ(PASS_OPER, ret); + ASSERT_EQ(PASS_OPER, AccessTokenKit::GetSelfPermissionsState(permsList241, info)); ASSERT_EQ(static_cast(2), permsList241.size()); ASSERT_EQ(PASS_OPER, permsList241[0].state); ASSERT_EQ(SETTING_OPER, permsList241[1].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -1262,33 +1358,33 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState025, TestSize.Le permsList25.emplace_back(permBack25); PermissionGrantInfo info; - PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList25, info); - ASSERT_EQ(PASS_OPER, ret); + ASSERT_EQ(PASS_OPER, AccessTokenKit::GetSelfPermissionsState(permsList25, info)); ASSERT_EQ(static_cast(3), permsList25.size()); ASSERT_EQ(INVALID_OPER, permsList25[0].state); ASSERT_EQ(INVALID_OPER, permsList25[1].state); ASSERT_EQ(INVALID_OPER, permsList25[2].state); // grant back permission, get accerate&vague again, ret: PASS_OPER, state: SETTING_OPER + INVALID_OPER - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GrantPermission( + ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest( tokenID, "ohos.permission.LOCATION_IN_BACKGROUND", PermissionFlag::PERMISSION_USER_FIXED)); std::vector permsList251; permsList251.emplace_back(permVague25); permsList251.emplace_back(permAccurate25); - ret = AccessTokenKit::GetSelfPermissionsState(permsList251, info); - ASSERT_EQ(PASS_OPER, ret); + ASSERT_EQ(PASS_OPER, AccessTokenKit::GetSelfPermissionsState(permsList251, info)); ASSERT_EQ(static_cast(2), permsList251.size()); ASSERT_EQ(SETTING_OPER, permsList251[0].state); ASSERT_EQ(INVALID_OPER, permsList251[1].state); // grant vague permission, get accerate&vague again, ret: DYNAMIC_OPER, state: PASS_OPER + DYNAMIC_OPER - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GrantPermission( + ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest( tokenID, "ohos.permission.APPROXIMATELY_LOCATION", PermissionFlag::PERMISSION_USER_FIXED)); - ret = AccessTokenKit::GetSelfPermissionsState(permsList251, info); - ASSERT_EQ(DYNAMIC_OPER, ret); + ASSERT_EQ(DYNAMIC_OPER, AccessTokenKit::GetSelfPermissionsState(permsList251, info)); ASSERT_EQ(static_cast(2), permsList251.size()); ASSERT_EQ(PASS_OPER, permsList251[0].state); ASSERT_EQ(DYNAMIC_OPER, permsList251[1].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -1328,33 +1424,33 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState026, TestSize.Le permsList26.emplace_back(permBack26); PermissionGrantInfo info; - PermissionOper ret = AccessTokenKit::GetSelfPermissionsState(permsList26, info); - ASSERT_EQ(PASS_OPER, ret); + ASSERT_EQ(PASS_OPER, AccessTokenKit::GetSelfPermissionsState(permsList26, info)); ASSERT_EQ(static_cast(3), permsList26.size()); ASSERT_EQ(INVALID_OPER, permsList26[0].state); ASSERT_EQ(INVALID_OPER, permsList26[1].state); ASSERT_EQ(INVALID_OPER, permsList26[2].state); // grant back permission, get accerate&vague again, ret: PASS_OPER, state: SETTING_OPER + SETTING_OPER - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GrantPermission( + ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest( tokenID, "ohos.permission.LOCATION_IN_BACKGROUND", PermissionFlag::PERMISSION_USER_FIXED)); std::vector permsList261; permsList261.emplace_back(permVague26); permsList261.emplace_back(permAccurate26); - ret = AccessTokenKit::GetSelfPermissionsState(permsList261, info); - ASSERT_EQ(PASS_OPER, ret); + ASSERT_EQ(PASS_OPER, AccessTokenKit::GetSelfPermissionsState(permsList261, info)); ASSERT_EQ(static_cast(2), permsList261.size()); ASSERT_EQ(SETTING_OPER, permsList261[0].state); ASSERT_EQ(SETTING_OPER, permsList261[1].state); // grant vague permission, get accerate&vague again, ret: PASS_OPER, state: PASS_OPER + SETTING_OPER - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GrantPermission( + ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest( tokenID, "ohos.permission.APPROXIMATELY_LOCATION", PermissionFlag::PERMISSION_USER_FIXED)); - ret = AccessTokenKit::GetSelfPermissionsState(permsList261, info); - ASSERT_EQ(PASS_OPER, ret); + ASSERT_EQ(PASS_OPER, AccessTokenKit::GetSelfPermissionsState(permsList261, info)); ASSERT_EQ(static_cast(2), permsList261.size()); ASSERT_EQ(PASS_OPER, permsList261[0].state); ASSERT_EQ(SETTING_OPER, permsList261[1].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -1414,6 +1510,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState027, TestSize.Le ASSERT_EQ(INVALID_OPER, permsList27[2].state); ASSERT_EQ(PASS_OPER, permsList27[3].state); ASSERT_EQ(DYNAMIC_OPER, permsList27[4].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -1445,6 +1544,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState028, TestSize.Le ASSERT_EQ(PASS_OPER, ret); ASSERT_EQ(static_cast(1), permsList28.size()); ASSERT_EQ(INVALID_OPER, permsList28[0].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -1476,6 +1578,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState029, TestSize.Le ASSERT_EQ(DYNAMIC_OPER, ret); ASSERT_EQ(static_cast(1), permsList29.size()); ASSERT_EQ(DYNAMIC_OPER, permsList29[0].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -1507,6 +1612,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState030, TestSize.Le ASSERT_EQ(DYNAMIC_OPER, ret); ASSERT_EQ(static_cast(1), permsList30.size()); ASSERT_EQ(DYNAMIC_OPER, permsList30[0].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -1545,6 +1653,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState031, TestSize.Le ASSERT_EQ(static_cast(2), permsList31.size()); ASSERT_EQ(INVALID_OPER, permsList31[0].state); ASSERT_EQ(DYNAMIC_OPER, permsList31[1].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -1583,6 +1694,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState032, TestSize.Le ASSERT_EQ(static_cast(2), permsList32.size()); ASSERT_EQ(INVALID_OPER, permsList32[0].state); ASSERT_EQ(DYNAMIC_OPER, permsList32[1].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -1620,6 +1734,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState033, TestSize.Le ASSERT_EQ(DYNAMIC_OPER, ret); ASSERT_EQ(static_cast(2), permsList33.size()); ASSERT_EQ(DYNAMIC_OPER, permsList33[0].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -1665,6 +1782,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState034, TestSize.Le ASSERT_EQ(INVALID_OPER, permsList34[0].state); ASSERT_EQ(DYNAMIC_OPER, permsList34[1].state); ASSERT_EQ(DYNAMIC_OPER, permsList34[2].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -1705,7 +1825,7 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState035, TestSize.Le ASSERT_EQ(SETTING_OPER, permsList35[1].state); // grant back permission, get vague again, ret: DYNAMIC_OPER, state: DYNAMIC_OPER - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GrantPermission( + ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest( tokenID, "ohos.permission.LOCATION_IN_BACKGROUND", PermissionFlag::PERMISSION_USER_FIXED)); std::vector permsList351; permsList351.emplace_back(permVague35); @@ -1713,6 +1833,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState035, TestSize.Le ASSERT_EQ(DYNAMIC_OPER, ret); ASSERT_EQ(static_cast(1), permsList351.size()); ASSERT_EQ(DYNAMIC_OPER, permsList351[0].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -1751,6 +1874,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState036, TestSize.Le ASSERT_EQ(static_cast(2), permsList36.size()); ASSERT_EQ(PASS_OPER, permsList36[0].state); ASSERT_EQ(INVALID_OPER, permsList36[1].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -1789,6 +1915,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState037, TestSize.Le ASSERT_EQ(static_cast(2), permsList37.size()); ASSERT_EQ(SETTING_OPER, permsList37[0].state); ASSERT_EQ(INVALID_OPER, permsList37[1].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -1827,6 +1956,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState038, TestSize.Le ASSERT_EQ(static_cast(2), permsList38.size()); ASSERT_EQ(PASS_OPER, permsList38[0].state); ASSERT_EQ(PASS_OPER, permsList38[1].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -1865,6 +1997,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState039, TestSize.Le ASSERT_EQ(static_cast(2), permsList39.size()); ASSERT_EQ(INVALID_OPER, permsList39[0].state); ASSERT_EQ(INVALID_OPER, permsList39[1].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -1904,6 +2039,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState040, TestSize.Le ASSERT_EQ(static_cast(2), permsList40.size()); ASSERT_EQ(DYNAMIC_OPER, permsList40[0].state); ASSERT_EQ(SETTING_OPER, permsList40[1].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -1949,6 +2087,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState041, TestSize.Le ASSERT_EQ(DYNAMIC_OPER, permsList41[0].state); ASSERT_EQ(DYNAMIC_OPER, permsList41[1].state); ASSERT_EQ(SETTING_OPER, permsList41[2].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -1994,6 +2135,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState042, TestSize.Le ASSERT_EQ(PASS_OPER, permsList42[0].state); ASSERT_EQ(DYNAMIC_OPER, permsList42[1].state); ASSERT_EQ(SETTING_OPER, permsList42[2].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -2039,6 +2183,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState043, TestSize.Le ASSERT_EQ(PASS_OPER, permsList43[0].state); ASSERT_EQ(PASS_OPER, permsList43[1].state); ASSERT_EQ(INVALID_OPER, permsList43[2].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -2084,6 +2231,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState044, TestSize.Le ASSERT_EQ(PASS_OPER, permsList44[0].state); ASSERT_EQ(DYNAMIC_OPER, permsList44[1].state); ASSERT_EQ(PASS_OPER, permsList44[2].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -2129,6 +2279,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState045, TestSize.Le ASSERT_EQ(PASS_OPER, permsList45[0].state); ASSERT_EQ(PASS_OPER, permsList45[1].state); ASSERT_EQ(PASS_OPER, permsList45[2].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -2174,6 +2327,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState046, TestSize.Le ASSERT_EQ(SETTING_OPER, permsList46[0].state); ASSERT_EQ(INVALID_OPER, permsList46[1].state); ASSERT_EQ(INVALID_OPER, permsList46[2].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -2219,6 +2375,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState047, TestSize.Le ASSERT_EQ(SETTING_OPER, permsList47[0].state); ASSERT_EQ(SETTING_OPER, permsList47[1].state); ASSERT_EQ(INVALID_OPER, permsList47[2].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -2264,6 +2423,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState048, TestSize.Le ASSERT_EQ(SETTING_OPER, permsList48[0].state); ASSERT_EQ(INVALID_OPER, permsList48[1].state); ASSERT_EQ(SETTING_OPER, permsList48[2].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -2309,6 +2471,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState049, TestSize.Le ASSERT_EQ(SETTING_OPER, permsList49[0].state); ASSERT_EQ(SETTING_OPER, permsList49[1].state); ASSERT_EQ(SETTING_OPER, permsList49[2].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -2368,6 +2533,9 @@ HWTEST_F(AccessTokenLocationRequestTest, GetSelfPermissionsState050, TestSize.Le ASSERT_EQ(SETTING_OPER, permsList50[2].state); ASSERT_EQ(PASS_OPER, permsList50[3].state); ASSERT_EQ(DYNAMIC_OPER, permsList50[4].state); + + ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } } // namespace AccessToken } // namespace Security diff --git a/interfaces/innerkits/accesstoken/test/unittest/src/accesstoken_location_request_test.h b/interfaces/innerkits/accesstoken/test/unittest/PermisionDialogTest/accesstoken_location_request_test.h similarity index 97% rename from interfaces/innerkits/accesstoken/test/unittest/src/accesstoken_location_request_test.h rename to interfaces/innerkits/accesstoken/test/unittest/PermisionDialogTest/accesstoken_location_request_test.h index 05de435ee8daec769b76afa939dc94e3b2c62916..734d57c510d31c9c0f4f8e848f215a283a2d4c1c 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/src/accesstoken_location_request_test.h +++ b/interfaces/innerkits/accesstoken/test/unittest/PermisionDialogTest/accesstoken_location_request_test.h @@ -28,11 +28,8 @@ class AccessTokenLocationRequestTest : public testing::Test { public: static void SetUpTestCase(); static void TearDownTestCase(); - void SetUp(); void TearDown(); - - uint64_t selfTokenId_; }; } // namespace AccessToken } // namespace Security diff --git a/interfaces/innerkits/accesstoken/test/unittest/src/get_self_permission_state_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/PermisionDialogTest/get_self_permission_state_test.cpp similarity index 62% rename from interfaces/innerkits/accesstoken/test/unittest/src/get_self_permission_state_test.cpp rename to interfaces/innerkits/accesstoken/test/unittest/PermisionDialogTest/get_self_permission_state_test.cpp index ae7b90c5a3c0cf3158645cb3dc163838230c972f..e183d79616fbc4dddd2cb9010e5746ad737ec8b4 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/src/get_self_permission_state_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/PermisionDialogTest/get_self_permission_state_test.cpp @@ -14,6 +14,7 @@ */ #include "get_self_permission_state_test.h" #include "nativetoken_kit.h" +#include "test_common.h" #include "token_setproc.h" namespace OHOS { @@ -24,172 +25,72 @@ namespace { static const int MAX_PERMISSION_SIZE = 1000; static const std::string TEST_BUNDLE_NAME = "ohos"; static const int TEST_USER_ID = 0; -static const std::string TEST_PERMISSION_NAME_A_MICRO = "ohos.permission.MICROPHONE"; -static const std::string TEST_PERMISSION_NAME_A_CAMERA = "ohos.permission.SET_WIFI_INFO"; -PermissionDef g_permDef1 = { - .permissionName = "ohos.permission.test1", - .bundleName = "accesstoken_test", - .grantMode = 1, - .availableLevel = APL_NORMAL, - .label = "label2", - .labelId = 1, - .description = "open the door", - .descriptionId = 1 +static const std::string LOCATION_PERMISSION = "ohos.permission.LOCATION"; +static const std::string APPROXIMATELY_LOCATION_PERMISSION = "ohos.permission.APPROXIMATELY_LOCATION"; +static const std::string LOCATION_IN_BACKGROUND_PERMISSION = "ohos.permission.LOCATION_IN_BACKGROUND"; +PermissionStateFull g_permTestState1 = { + .permissionName = LOCATION_PERMISSION, + .isGeneral = true, + .resDeviceID = {"local"}, + .grantStatus = {PermissionState::PERMISSION_DENIED}, + .grantFlags = {PermissionFlag::PERMISSION_DEFAULT_FLAG}, }; -PermissionDef g_permDef2 = { - .permissionName = "ohos.permission.test2", - .bundleName = "accesstoken_test", - .grantMode = 1, - .availableLevel = APL_NORMAL, - .label = "label2", - .labelId = 1, - .description = "break the door", - .descriptionId = 1 +PermissionStateFull g_permTestState2 = { + .permissionName = "ohos.permission.MICROPHONE", + .isGeneral = true, + .resDeviceID = {"local"}, + .grantStatus = {PermissionState::PERMISSION_DENIED}, + .grantFlags = {PermissionFlag::PERMISSION_USER_SET} }; -HapInfoParams g_infoManager = { - .userID = 1, - .bundleName = "accesstoken_test", - .instIndex = 0, - .appIDDesc = "test2", - .apiVersion = 8 // 8: api version +PermissionStateFull g_permTestState3 = { + .permissionName = "ohos.permission.WRITE_CALENDAR", + .isGeneral = true, + .resDeviceID = {"local"}, + .grantStatus = {PermissionState::PERMISSION_DENIED}, + .grantFlags = {PermissionFlag::PERMISSION_USER_FIXED} }; -PermissionStateFull g_permState1 = { - .permissionName = "ohos.permission.test1", +PermissionStateFull g_permTestState4 = { + .permissionName = "ohos.permission.READ_IMAGEVIDEO", .isGeneral = true, - .resDeviceID = {"local2"}, + .resDeviceID = {"local"}, .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {1} + .grantFlags = {PermissionFlag::PERMISSION_USER_SET} }; -PermissionStateFull g_permState2 = { - .permissionName = "ohos.permission.test2", - .isGeneral = false, - .resDeviceID = {"device 1", "device 2"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED, PermissionState::PERMISSION_GRANTED}, - .grantFlags = {1, 2} +HapInfoParams g_infoManager = { + .userID = 1, + .bundleName = "accesstoken_test", + .instIndex = 0, + .appIDDesc = "test2", + .apiVersion = 8 // 8: api version }; -HapPolicyParams g_infoManagerTestPolicyPrams = { +HapPolicyParams g_policy = { .apl = APL_NORMAL, - .domain = "test.domain2", - .permList = {g_permDef1, g_permDef2}, - .permStateList = {g_permState1, g_permState2} + .domain = "domain", + .permStateList = {g_permTestState1, g_permTestState2, g_permTestState3, g_permTestState4} }; + +static uint64_t g_selfTokenId = 0; } void GetSelfPermissionStateTest::SetUpTestCase() { - setuid(0); - const char **perms = new const char *[1]; // 1: array size - perms[0] = "ohos.permission.DISABLE_PERMISSION_DIALOG"; - - NativeTokenInfoParams infoInstance = { - .dcapsNum = 0, - .permsNum = 1, // 1: array size - .aclsNum = 0, - .dcaps = nullptr, - .perms = perms, - .acls = nullptr, - .aplStr = "system_core", - .processName = "TestCase", - }; - - uint64_t tokenId = GetAccessTokenId(&infoInstance); - AccessTokenKit::ReloadNativeTokenInfo(); - - EXPECT_EQ(0, SetSelfTokenID(tokenId)); - delete[] perms; + g_selfTokenId = GetSelfTokenID(); + TestCommon::SetTestEvironment(g_selfTokenId); } void GetSelfPermissionStateTest::TearDownTestCase() { -} - -void InitPermStateList(HapPolicyParams &policy) -{ - PermissionStateFull permTestState1 = { - .permissionName = "ohos.permission.LOCATION", - .isGeneral = true, - .resDeviceID = {"local"}, - .grantStatus = {PermissionState::PERMISSION_DENIED}, - .grantFlags = {PermissionFlag::PERMISSION_DEFAULT_FLAG}, - }; - - PermissionStateFull permTestState2 = { - .permissionName = "ohos.permission.MICROPHONE", - .isGeneral = true, - .resDeviceID = {"local"}, - .grantStatus = {PermissionState::PERMISSION_DENIED}, - .grantFlags = {PermissionFlag::PERMISSION_USER_SET} - }; - - PermissionStateFull permTestState3 = { - .permissionName = "ohos.permission.WRITE_CALENDAR", - .isGeneral = true, - .resDeviceID = {"local"}, - .grantStatus = {PermissionState::PERMISSION_DENIED}, - .grantFlags = {PermissionFlag::PERMISSION_USER_FIXED} - }; - - PermissionStateFull permTestState4 = { - .permissionName = "ohos.permission.READ_IMAGEVIDEO", - .isGeneral = true, - .resDeviceID = {"local"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {PermissionFlag::PERMISSION_USER_SET} - }; - policy.permStateList.emplace_back(permTestState1); - policy.permStateList.emplace_back(permTestState2); - policy.permStateList.emplace_back(permTestState3); - policy.permStateList.emplace_back(permTestState4); -} - -void InitPermDefList(HapPolicyParams &policy) -{ - PermissionDef testPermDef1; - testPermDef1.permissionName = "ohos.permission.testPermDef1"; - testPermDef1.bundleName = TEST_BUNDLE_NAME; - testPermDef1.grantMode = GrantMode::USER_GRANT; - testPermDef1.availableLevel = APL_NORMAL; - testPermDef1.provisionEnable = false; - testPermDef1.distributedSceneEnable = false; - - PermissionDef testPermDef2; - testPermDef2.permissionName = "ohos.permission.testPermDef2"; - testPermDef2.bundleName = TEST_BUNDLE_NAME; - testPermDef2.grantMode = GrantMode::USER_GRANT; - testPermDef2.availableLevel = APL_NORMAL; - testPermDef2.provisionEnable = false; - testPermDef2.distributedSceneEnable = false; - - PermissionDef testPermDef3; - testPermDef3.permissionName = "ohos.permission.testPermDef3"; - testPermDef3.bundleName = TEST_BUNDLE_NAME; - testPermDef3.grantMode = GrantMode::USER_GRANT; - testPermDef3.availableLevel = APL_NORMAL; - testPermDef3.provisionEnable = false; - testPermDef3.distributedSceneEnable = false; - - PermissionDef testPermDef4; - testPermDef4.permissionName = "ohos.permission.testPermDef4"; - testPermDef4.bundleName = TEST_BUNDLE_NAME; - testPermDef4.grantMode = GrantMode::USER_GRANT; - testPermDef4.availableLevel = APL_NORMAL; - testPermDef4.provisionEnable = false; - testPermDef4.distributedSceneEnable = false; - - policy.permList.emplace_back(testPermDef1); - policy.permList.emplace_back(testPermDef2); - policy.permList.emplace_back(testPermDef3); - policy.permList.emplace_back(testPermDef4); + ASSERT_EQ(RET_SUCCESS, SetSelfTokenID(g_selfTokenId)); + TestCommon::ResetTestEvironment(); } void GetSelfPermissionStateTest::SetUp() { - selfTokenId_ = GetSelfTokenID(); HapInfoParams info = { .userID = TEST_USER_ID, .bundleName = TEST_BUNDLE_NAME, @@ -198,51 +99,25 @@ void GetSelfPermissionStateTest::SetUp() .apiVersion = 8 // 8: api version }; - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "domain", - }; - InitPermStateList(policy); - InitPermDefList(policy); - AccessTokenKit::AllocHapToken(info, policy); + AccessTokenIDEx tokenIdEx = TestCommon::AllocAndGrantHapTokenByTest(info, g_policy); + AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(tokenId, INVALID_TOKENID); + ASSERT_EQ(RET_SUCCESS, SetSelfTokenID(tokenIdEx.tokenIDEx)); } void GetSelfPermissionStateTest::TearDown() { - SetSelfTokenID(selfTokenId_); - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenID); - DeleteTestToken(); -} - -unsigned int GetSelfPermissionStateTest::GetAccessTokenID(int userID, std::string bundleName, int instIndex) -{ - return AccessTokenKit::GetHapTokenID(userID, bundleName, instIndex); -} - -AccessTokenID GetSelfPermissionStateTest::AllocTestToken( - const HapInfoParams& hapInfo, const HapPolicyParams& hapPolicy) const -{ - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(hapInfo, hapPolicy); - return tokenIdEx.tokenIdExStruct.tokenID; -} - -void GetSelfPermissionStateTest::DeleteTestToken() const -{ - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoManager.userID, - g_infoManager.bundleName, - g_infoManager.instIndex); - int ret = AccessTokenKit::DeleteToken(tokenID); - if (tokenID != 0) { - ASSERT_EQ(RET_SUCCESS, ret); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID; + if (tokenId != INVALID_TOKENID) { + EXPECT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenId)); } } void GetPermsList1(std::vector &permsList1) { PermissionListState perm1 = { - .permissionName = "ohos.permission.LOCATION", + .permissionName = LOCATION_PERMISSION, .state = SETTING_OPER, }; PermissionListState perm2 = { @@ -285,9 +160,9 @@ void GetPermsList2(std::vector &permsList2) */ HWTEST_F(GetSelfPermissionStateTest, GetSelfPermissionsState001, TestSize.Level1) { - AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; ASSERT_NE(INVALID_TOKENID, tokenID); - ASSERT_EQ(0, SetSelfTokenID(tokenID)); std::vector permsList1; GetPermsList1(permsList1); @@ -299,7 +174,7 @@ HWTEST_F(GetSelfPermissionStateTest, GetSelfPermissionsState001, TestSize.Level1 ASSERT_EQ(DYNAMIC_OPER, permsList1[1].state); ASSERT_EQ(SETTING_OPER, permsList1[2].state); ASSERT_EQ(PASS_OPER, permsList1[3].state); - ASSERT_EQ("ohos.permission.LOCATION", permsList1[0].permissionName); + ASSERT_EQ(LOCATION_PERMISSION, permsList1[0].permissionName); ASSERT_EQ("ohos.permission.MICROPHONE", permsList1[1].permissionName); ASSERT_EQ("ohos.permission.WRITE_CALENDAR", permsList1[2].permissionName); ASSERT_EQ("ohos.permission.READ_IMAGEVIDEO", permsList1[3].permissionName); @@ -364,8 +239,7 @@ HWTEST_F(GetSelfPermissionStateTest, GetSelfPermissionsState002, TestSize.Level1 */ HWTEST_F(GetSelfPermissionStateTest, GetSelfPermissionsState003, TestSize.Level1) { - AccessTokenID tokenId = AccessTokenKit::GetNativeTokenId("hdcd"); - EXPECT_EQ(0, SetSelfTokenID(tokenId)); + MockNativeToken mock("hdcd"); std::vector permsList3; PermissionListState tmp = { .permissionName = "ohos.permission.CAMERA", @@ -384,9 +258,9 @@ HWTEST_F(GetSelfPermissionStateTest, GetSelfPermissionsState003, TestSize.Level1 */ HWTEST_F(GetSelfPermissionStateTest, GetSelfPermissionsState004, TestSize.Level1) { - AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - EXPECT_EQ(0, SetSelfTokenID(tokenId)); - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenId)); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenId)); std::vector permsList4; PermissionListState tmp = { .permissionName = "ohos.permission.CAMERA", @@ -399,14 +273,12 @@ HWTEST_F(GetSelfPermissionStateTest, GetSelfPermissionsState004, TestSize.Level1 /** * @tc.name: GetSelfPermissionsState005 - * @tc.desc: test noexist token id + * @tc.desc: test noexist permission * @tc.type: FUNC * @tc.require: */ HWTEST_F(GetSelfPermissionStateTest, GetSelfPermissionsState005, TestSize.Level1) { - AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - EXPECT_EQ(0, SetSelfTokenID(tokenId)); std::vector permsList4; PermissionListState tmp = { .permissionName = "ohos.permission.SHORT_TERM_WRITE_IMAGEVIDEO", @@ -415,10 +287,8 @@ HWTEST_F(GetSelfPermissionStateTest, GetSelfPermissionsState005, TestSize.Level1 permsList4.emplace_back(tmp); PermissionGrantInfo info; ASSERT_EQ(PASS_OPER, AccessTokenKit::GetSelfPermissionsState(permsList4, info)); - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenId)); } - /** * @tc.name: GetSelfPermissionsState006 * @tc.desc: get self permissions state with wrong token type. @@ -427,23 +297,28 @@ HWTEST_F(GetSelfPermissionStateTest, GetSelfPermissionsState005, TestSize.Level1 */ HWTEST_F(GetSelfPermissionStateTest, GetSelfPermissionsState006, TestSize.Level1) { - AccessTokenID tokenID = AllocTestToken(g_infoManager, g_infoManagerTestPolicyPrams); - HapBaseInfo hapBaseInfo = { - .userID = g_infoManager.userID, - .bundleName = g_infoManager.bundleName, - .instIndex = g_infoManager.instIndex, - }; - std::vector permsList; PermissionListState tmp = { - .permissionName = g_infoManagerTestPolicyPrams.permStateList[0].permissionName, + .permissionName = g_policy.permStateList[0].permissionName, .state = BUTT_OPER }; permsList.emplace_back(tmp); - // test dialog isn't forbiddedn - ASSERT_EQ(0, AccessTokenKit::SetPermDialogCap(hapBaseInfo, false)); - SetSelfTokenID(tokenID); + { + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.DISABLE_PERMISSION_DIALOG"); + MockHapToken mock("GetSelfPermissionsState006", reqPerm, true); + + HapBaseInfo hapBaseInfo = { + .userID = TEST_USER_ID, + .bundleName = TEST_BUNDLE_NAME, + .instIndex = 0, + }; + + // test dialog isn't forbiddedn + ASSERT_EQ(0, AccessTokenKit::SetPermDialogCap(hapBaseInfo, false)); + } + PermissionGrantInfo info; ASSERT_EQ(INVALID_OPER, AccessTokenKit::GetSelfPermissionsState(permsList, info)); } @@ -475,7 +350,7 @@ HapPolicyParams GetPolicyParam() }; //test CONDITIONS_NOT_MET PermissionStateFull permState4 = { - .permissionName = "ohos.permission.APPROXIMATELY_LOCATION", + .permissionName = APPROXIMATELY_LOCATION_PERMISSION, .isGeneral = true, .resDeviceID = {"local3"}, .grantStatus = {PermissionState::PERMISSION_DENIED}, @@ -507,8 +382,11 @@ HapPolicyParams GetPolicyParam() HWTEST_F(GetSelfPermissionStateTest, GetSelfPermissionsState007, TestSize.Level1) { HapPolicyParams policyParam = GetPolicyParam(); - AccessTokenID tokenID = AllocTestToken(g_infoManager, policyParam); - + AccessTokenIDEx tokenIdEx = TestCommon::AllocAndGrantHapTokenByTest(g_infoManager, policyParam); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(tokenID, INVALID_TOKENID); + EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); // set self hap token + PermissionListState permInvalid = { .permissionName = "ohos.permission.WU_ERROR_REASON", .state = FORBIDDEN_OPER @@ -527,7 +405,6 @@ HWTEST_F(GetSelfPermissionStateTest, GetSelfPermissionsState007, TestSize.Level1 }; permsList.emplace_back(tmp); } - SetSelfTokenID(tokenID); PermissionGrantInfo info; ASSERT_EQ(DYNAMIC_OPER, AccessTokenKit::GetSelfPermissionsState(permsList, info)); EXPECT_EQ(permsList[0].errorReason, PERM_INVALID); @@ -537,7 +414,8 @@ HWTEST_F(GetSelfPermissionStateTest, GetSelfPermissionsState007, TestSize.Level1 EXPECT_EQ(permsList[4].errorReason, UNABLE_POP_UP); EXPECT_EQ(permsList[5].errorReason, CONDITIONS_NOT_MET); EXPECT_EQ(permsList[6].errorReason, REQ_SUCCESS); - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); + ASSERT_EQ(RET_SUCCESS, SetSelfTokenID(g_selfTokenId)); } /** @@ -550,12 +428,11 @@ HWTEST_F(GetSelfPermissionStateTest, GetSelfPermissionsState007, TestSize.Level1 HWTEST_F(GetSelfPermissionStateTest, GetSelfPermissionsState008, TestSize.Level1) { HapPolicyParams policyParam = GetPolicyParam(); - AccessTokenID tokenID = AllocTestToken(g_infoManager, policyParam); - HapBaseInfo hapBaseInfo = { - .userID = g_infoManager.userID, - .bundleName = g_infoManager.bundleName, - .instIndex = g_infoManager.instIndex, - }; + AccessTokenIDEx tokenIdEx = TestCommon::AllocAndGrantHapTokenByTest(g_infoManager, policyParam); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(tokenID, INVALID_TOKENID); + EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); // set self hap token + std::vector permsList; for (auto& perm : policyParam.permStateList) { PermissionListState tmp = { @@ -564,8 +441,21 @@ HWTEST_F(GetSelfPermissionStateTest, GetSelfPermissionsState008, TestSize.Level1 }; permsList.emplace_back(tmp); } - ASSERT_EQ(0, AccessTokenKit::SetPermDialogCap(hapBaseInfo, true)); - SetSelfTokenID(tokenID); + { + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.DISABLE_PERMISSION_DIALOG"); + MockHapToken mock("GetSelfPermissionsState008", reqPerm, true); + + HapBaseInfo hapBaseInfo = { + .userID = g_infoManager.userID, + .bundleName = g_infoManager.bundleName, + .instIndex = g_infoManager.instIndex, + }; + + // test dialog isn't forbiddedn + ASSERT_EQ(0, AccessTokenKit::SetPermDialogCap(hapBaseInfo, true)); + } + PermissionGrantInfo info; ASSERT_EQ(FORBIDDEN_OPER, AccessTokenKit::GetSelfPermissionsState(permsList, info)); EXPECT_EQ(permsList[0].errorReason, PRIVACY_STATEMENT_NOT_AGREED); @@ -573,7 +463,8 @@ HWTEST_F(GetSelfPermissionStateTest, GetSelfPermissionsState008, TestSize.Level1 EXPECT_EQ(permsList[2].errorReason, UNABLE_POP_UP); EXPECT_EQ(permsList[3].errorReason, CONDITIONS_NOT_MET); EXPECT_EQ(permsList[4].errorReason, PRIVACY_STATEMENT_NOT_AGREED); - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); + ASSERT_EQ(RET_SUCCESS, SetSelfTokenID(g_selfTokenId)); } HapPolicyParams getHapPolicyLocationParams(const std::vector& permissions) @@ -605,33 +496,32 @@ HapPolicyParams getHapPolicyLocationParams(const std::vector& permi */ HWTEST_F(GetSelfPermissionStateTest, GetSelfPermissionsState009, TestSize.Level1) { - std::string location = "ohos.permission.LOCATION"; - std::string vague = "ohos.permission.APPROXIMATELY_LOCATION"; - std::string background = "ohos.permission.LOCATION_IN_BACKGROUND"; - std::vector permissions = {location, vague}; + std::vector permissions = {LOCATION_PERMISSION, APPROXIMATELY_LOCATION_PERMISSION}; HapPolicyParams policyParam = getHapPolicyLocationParams(permissions); HapInfoParams hapInfo = g_infoManager; hapInfo.apiVersion = 14; - AccessTokenID tokenID = AllocTestToken(hapInfo, policyParam); + + AccessTokenIDEx tokenIdEx = TestCommon::AllocAndGrantHapTokenByTest(hapInfo, policyParam); + ASSERT_NE(tokenIdEx.tokenIdExStruct.tokenID, INVALID_TOKENID); + EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); // set self hap token + std::vector permsList; PermissionListState locationState = { - .permissionName = vague, + .permissionName = APPROXIMATELY_LOCATION_PERMISSION, .state = FORBIDDEN_OPER }; permsList.emplace_back(locationState); - SetSelfTokenID(tokenID); PermissionGrantInfo info; - ASSERT_EQ(DYNAMIC_OPER, AccessTokenKit::GetSelfPermissionsState(permsList, info)); EXPECT_EQ(permsList[0].errorReason, REQ_SUCCESS); - locationState.permissionName = location; + locationState.permissionName = LOCATION_PERMISSION; permsList.emplace_back(locationState); ASSERT_EQ(DYNAMIC_OPER, AccessTokenKit::GetSelfPermissionsState(permsList, info)); EXPECT_EQ(permsList[0].errorReason, REQ_SUCCESS); EXPECT_EQ(permsList[1].errorReason, REQ_SUCCESS); - permsList[1].permissionName = background; + permsList[1].permissionName = LOCATION_IN_BACKGROUND_PERMISSION; ASSERT_EQ(PASS_OPER, AccessTokenKit::GetSelfPermissionsState(permsList, info)); EXPECT_EQ(permsList[0].errorReason, CONDITIONS_NOT_MET); EXPECT_EQ(permsList[1].errorReason, CONDITIONS_NOT_MET); @@ -640,28 +530,28 @@ HWTEST_F(GetSelfPermissionStateTest, GetSelfPermissionsState009, TestSize.Level1 ASSERT_EQ(PASS_OPER, AccessTokenKit::GetSelfPermissionsState(locationPermsList, info)); EXPECT_EQ(locationPermsList[0].errorReason, CONDITIONS_NOT_MET); - SetSelfTokenID(selfTokenId_); - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GrantPermission(tokenID, vague, PERMISSION_USER_FIXED)); - SetSelfTokenID(tokenID); + ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest( + tokenIdEx.tokenIdExStruct.tokenID, APPROXIMATELY_LOCATION_PERMISSION, PERMISSION_USER_FIXED)); ASSERT_EQ(DYNAMIC_OPER, AccessTokenKit::GetSelfPermissionsState(locationPermsList, info)); EXPECT_EQ(locationPermsList[0].errorReason, REQ_SUCCESS); - locationState.permissionName = background; + locationState.permissionName = LOCATION_IN_BACKGROUND_PERMISSION; std::vector backgroundPermsList = {locationState}; ASSERT_EQ(PASS_OPER, AccessTokenKit::GetSelfPermissionsState(backgroundPermsList, info)); EXPECT_EQ(backgroundPermsList[0].errorReason, CONDITIONS_NOT_MET); - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); - - std::vector vaguePermissions = {vague}; + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID)); + std::vector vaguePermissions = {APPROXIMATELY_LOCATION_PERMISSION}; policyParam = getHapPolicyLocationParams(vaguePermissions); - tokenID = AllocTestToken(hapInfo, policyParam); - SetSelfTokenID(tokenID); + + tokenIdEx = TestCommon::AllocAndGrantHapTokenByTest(hapInfo, policyParam); + ASSERT_NE(tokenIdEx.tokenIdExStruct.tokenID, INVALID_TOKENID); + EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); // set self hap token ASSERT_EQ(PASS_OPER, AccessTokenKit::GetSelfPermissionsState(locationPermsList, info)); EXPECT_EQ(locationPermsList[0].errorReason, PERM_NOT_DECLEARED); - - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID)); + EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId)); // set self hap token } } // namespace AccessToken } // namespace Security diff --git a/interfaces/innerkits/accesstoken/test/unittest/src/get_self_permission_state_test.h b/interfaces/innerkits/accesstoken/test/unittest/PermisionDialogTest/get_self_permission_state_test.h similarity index 98% rename from interfaces/innerkits/accesstoken/test/unittest/src/get_self_permission_state_test.h rename to interfaces/innerkits/accesstoken/test/unittest/PermisionDialogTest/get_self_permission_state_test.h index ebbbc81effbad20d555338c58ab783c27ff3d567..5388814e33b154d515ee9b7cf0d717f49d60a4f3 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/src/get_self_permission_state_test.h +++ b/interfaces/innerkits/accesstoken/test/unittest/PermisionDialogTest/get_self_permission_state_test.h @@ -35,8 +35,6 @@ public: unsigned int GetAccessTokenID(int userID, std::string bundleName, int instIndex); AccessTokenID AllocTestToken(const HapInfoParams& hapInfo, const HapPolicyParams& hapPolicy) const; void DeleteTestToken() const; - - uint64_t selfTokenId_; }; } // namespace AccessToken } // namespace Security diff --git a/interfaces/innerkits/accesstoken/test/unittest/PermisionDialogTest/request_permission_on_setting_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/PermisionDialogTest/request_permission_on_setting_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..4d022d65e94db9c8bd5a82202729a93456c839fb --- /dev/null +++ b/interfaces/innerkits/accesstoken/test/unittest/PermisionDialogTest/request_permission_on_setting_test.cpp @@ -0,0 +1,142 @@ +/* + * Copyright (c) 1922 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 "request_permission_on_setting_test.h" + +#include "access_token.h" +#include "access_token_error.h" +#include "accesstoken_kit.h" +#include "test_common.h" +#include "token_setproc.h" + +using namespace testing::ext; + +namespace OHOS { +namespace Security { +namespace AccessToken { +namespace { +static uint64_t g_selfTokenId = 0; +} +void RequestPermissionOnSettingTest::SetUpTestCase() +{ + g_selfTokenId = GetSelfTokenID(); + TestCommon::SetTestEvironment(g_selfTokenId); +} + +void RequestPermissionOnSettingTest::TearDownTestCase() +{ + TestCommon::ResetTestEvironment(); +} + +void RequestPermissionOnSettingTest::SetUp() +{ +} + +void RequestPermissionOnSettingTest::TearDown() +{ +} + +/** + * @tc.name: RequestAppPermOnSettingTest001 + * @tc.desc: RequestAppPermOnSetting invalid token. + * @tc.type: FUNC + * @tc.require: Issue + */ +HWTEST_F(RequestPermissionOnSettingTest, RequestAppPermOnSettingTest001, TestSize.Level1) +{ + std::vector reqPerm; + MockHapToken mock("RequestPermissionOnSettingTest", reqPerm, true); + + // invalid tokenID in client + uint64_t tokenID = 0; + ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, AccessTokenKit::RequestAppPermOnSetting(tokenID)); + + GTEST_LOG_(INFO) << "------------2, tokenID is " << GetSelfTokenID(); + tokenID = 123; // 123: invalid token + ASSERT_EQ(AccessTokenError::ERR_TOKENID_NOT_EXIST, AccessTokenKit::RequestAppPermOnSetting(tokenID)); +} + +/** + * @tc.name: RequestAppPermOnSettingTest002 + * @tc.desc: RequestAppPermOnSetting not system app. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(RequestPermissionOnSettingTest, RequestAppPermOnSettingTest002, TestSize.Level0) +{ + std::vector reqPerm; + MockHapToken("RequestPermissionOnSettingTest", reqPerm, false); + + AccessTokenID tokenID = 123; + ASSERT_EQ(ERR_NOT_SYSTEM_APP, AccessTokenKit::RequestAppPermOnSetting(tokenID)); +} + +/** + * @tc.name: RequestAppPermOnSettingTest003 + * @tc.desc: RequestAppPermOnSetting add hap and call function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(RequestPermissionOnSettingTest, RequestAppPermOnSettingTest003, TestSize.Level0) +{ + std::vector reqPerm; + MockHapToken("RequestPermissionOnSettingTest", reqPerm, true); + + HapInfoParams infoManager = { + .userID = 1, + .bundleName = "accesstoken_test", + .instIndex = 0, + .appIDDesc = "test2", + .apiVersion = 8 // 8: api version + }; + + PermissionStateFull permState = { + .permissionName = "ohos.permission.CAMERA", + .isGeneral = true, + .resDeviceID = {"local2"}, + .grantStatus = {PermissionState::PERMISSION_GRANTED}, + .grantFlags = {1} + }; + + HapPolicyParams policyPrams = { + .apl = APL_NORMAL, + .domain = "test.domain2", + .permStateList = {permState} + }; + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ(RET_SUCCESS, TestCommon::AllocTestHapToken(infoManager, policyPrams, tokenIdEx)); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + AccessTokenKit::RequestAppPermOnSetting(tokenID); + + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); +} + +/** + * @tc.name: RequestAppPermOnSettingTest004 + * @tc.desc: RequestAppPermOnSetting call function with self token. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(RequestPermissionOnSettingTest, RequestAppPermOnSettingTest004, TestSize.Level0) +{ + std::vector reqPerm; + MockHapToken("RequestPermissionOnSettingTest", reqPerm, true); + + AccessTokenKit::RequestAppPermOnSetting(GetSelfTokenID()); +} +} // namespace AccessToken +} // namespace Security +} // namespace OHOS diff --git a/interfaces/innerkits/accesstoken/test/unittest/HapAttributeTest/get_self_permissions_state_test.h b/interfaces/innerkits/accesstoken/test/unittest/PermisionDialogTest/request_permission_on_setting_test.h similarity index 75% rename from interfaces/innerkits/accesstoken/test/unittest/HapAttributeTest/get_self_permissions_state_test.h rename to interfaces/innerkits/accesstoken/test/unittest/PermisionDialogTest/request_permission_on_setting_test.h index 5bac4f6fa9aa7aa222d689b899fb05eb3706120f..fbe91148786fd30cee3a8fc7421c77c6fc4701ff 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/HapAttributeTest/get_self_permissions_state_test.h +++ b/interfaces/innerkits/accesstoken/test/unittest/PermisionDialogTest/request_permission_on_setting_test.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024 Huawei Device Co., Ltd. + * Copyright (c) 2025 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 @@ -13,27 +13,26 @@ * limitations under the License. */ -#ifndef GET_SELF_PERMISSIONS_STATE_TEST_H -#define GET_SELF_PERMISSIONS_STATE_TEST_H +#ifndef REQUEST_PERMISSION_ON_SETTING_TEST_H +#define REQUEST_PERMISSION_ON_SETTING_TEST_H #include -#include "access_token.h" -#include "accesstoken_kit.h" #include "permission_def.h" #include "permission_state_full.h" namespace OHOS { namespace Security { namespace AccessToken { -class GetSelfPermissionsStateTest : public testing::Test { +class RequestPermissionOnSettingTest : public testing::Test { public: static void SetUpTestCase(); static void TearDownTestCase(); + void SetUp(); void TearDown(); }; } // namespace AccessToken } // namespace Security } // namespace OHOS -#endif // GET_SELF_PERMISSIONS_STATE_TEST_H \ No newline at end of file +#endif // REQUEST_PERMISSION_ON_SETTING_TEST_H diff --git a/interfaces/innerkits/accesstoken/test/unittest/HapAttributeTest/set_perm_dialog_cap_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/PermisionDialogTest/set_perm_dialog_cap_test.cpp similarity index 36% rename from interfaces/innerkits/accesstoken/test/unittest/HapAttributeTest/set_perm_dialog_cap_test.cpp rename to interfaces/innerkits/accesstoken/test/unittest/PermisionDialogTest/set_perm_dialog_cap_test.cpp index 36dc387529978ae5dbb247a9fded4ea7f7d2af68..3d6bab78ea08f30334c159604fc5322baaafc774 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/HapAttributeTest/set_perm_dialog_cap_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/PermisionDialogTest/set_perm_dialog_cap_test.cpp @@ -34,120 +34,48 @@ namespace OHOS { namespace Security { namespace AccessToken { namespace { -static AccessTokenID g_selfTokenId = 0; -static const std::string TEST_BUNDLE_NAME = "ohos"; -static const std::string TEST_PERMISSION_NAME_ALPHA = "ohos.permission.ALPHA"; -static const std::string TEST_PERMISSION_NAME_BETA = "ohos.permission.BETA"; -static const std::string TEST_PKG_NAME = "com.softbus.test"; -static const int TEST_USER_ID = 0; -static constexpr int32_t DEFAULT_API_VERSION = 8; -static const std::string TEST_PERMISSION_NAME_A_MICRO = "ohos.permission.MICROPHONE"; -static const std::string TEST_PERMISSION_NAME_A_CAMERA = "ohos.permission.SET_WIFI_INFO"; -static const int32_t INDEX_ZERO = 0; -static const int32_t INDEX_ONE = 1; -static const int32_t INDEX_TWO = 2; -static const int32_t INDEX_THREE = 3; -static const int32_t INDEX_FOUR = 4; - -HapInfoParams g_infoManagerTestInfoParms = TestCommon::GetInfoManagerTestInfoParms(); -HapPolicyParams g_infoManagerTestPolicyPrams = TestCommon::GetInfoManagerTestPolicyPrams(); - -HapInfoParams g_infoManagerTestInfoParmsBak = g_infoManagerTestInfoParms; -HapPolicyParams g_infoManagerTestPolicyPramsBak = g_infoManagerTestPolicyPrams; -} -uint64_t GetNativeToken(const char *processName, const char **perms, int32_t permNum) -{ - uint64_t tokenId; - NativeTokenInfoParams infoInstance = { - .dcapsNum = 0, - .permsNum = permNum, - .aclsNum = 0, - .dcaps = nullptr, - .perms = perms, - .acls = nullptr, - .aplStr = "system_core", - .processName = processName, - }; - - tokenId = GetAccessTokenId(&infoInstance); - AccessTokenKit::ReloadNativeTokenInfo(); - return tokenId; -} - -void NativeTokenGet1() -{ - uint64_t tokenID; - const char **perms = new const char *[5]; // 5: array size - perms[INDEX_ZERO] = "ohos.permission.DISTRIBUTED_DATASYNC"; - perms[INDEX_ONE] = "ohos.permission.GRANT_SENSITIVE_PERMISSIONS"; - perms[INDEX_TWO] = "ohos.permission.REVOKE_SENSITIVE_PERMISSIONS"; - perms[INDEX_THREE] = "ohos.permission.GET_SENSITIVE_PERMISSIONS"; - perms[INDEX_FOUR] = "ohos.permission.DISABLE_PERMISSION_DIALOG"; - - tokenID = GetNativeToken("TestCase", perms, 5); // 5: array size - EXPECT_EQ(0, SetSelfTokenID(tokenID)); - delete[] perms; +static uint64_t g_selfTokenId = 0; +PermissionStateFull g_permTestState = { + .permissionName = "ohos.permission.LOCATION", + .isGeneral = true, + .resDeviceID = {"local"}, + .grantStatus = {PermissionState::PERMISSION_DENIED}, + .grantFlags = {PermissionFlag::PERMISSION_DEFAULT_FLAG}, +}; + +HapInfoParams g_infoManager = { + .userID = 1, + .bundleName = "accesstoken_test", + .instIndex = 0, + .appIDDesc = "test2", + .apiVersion = 8 // 8: api version +}; + +HapPolicyParams g_policy = { + .apl = APL_NORMAL, + .domain = "domain", + .permStateList = {g_permTestState} +}; } void SetPermDialogCapTest::SetUpTestCase() { g_selfTokenId = GetSelfTokenID(); - setuid(0); - // make test case clean - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenID); - - NativeTokenGet1(); + TestCommon::SetTestEvironment(g_selfTokenId); } void SetPermDialogCapTest::TearDownTestCase() { SetSelfTokenID(g_selfTokenId); + TestCommon::ResetTestEvironment(); } void SetPermDialogCapTest::SetUp() { - selfTokenId_ = GetSelfTokenID(); - g_infoManagerTestPolicyPrams = g_infoManagerTestPolicyPramsBak; - g_infoManagerTestInfoParms = g_infoManagerTestInfoParmsBak; - HapInfoParams info = { - .userID = TEST_USER_ID, - .bundleName = TEST_BUNDLE_NAME, - .instIndex = 0, - .appIDDesc = "appIDDesc", - .apiVersion = DEFAULT_API_VERSION - }; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "domain" - }; - TestCommon::TestPreparePermDefList(policy); - TestCommon::TestPreparePermStateList(policy); - - AccessTokenKit::AllocHapToken(info, policy); - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); } void SetPermDialogCapTest::TearDown() { - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - EXPECT_EQ(0, SetSelfTokenID(selfTokenId_)); } /** @@ -158,6 +86,10 @@ void SetPermDialogCapTest::TearDown() */ HWTEST_F(SetPermDialogCapTest, SetPermDialogCapAbnormalTest001, TestSize.Level1) { + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.DISABLE_PERMISSION_DIALOG"); + MockHapToken mock("SetPermDialogCapAbnormalTest001", reqPerm, true); + LOGI(ATM_DOMAIN, ATM_TAG, "SetPermDialogCapAbnormalTest001"); HapBaseInfo hapBaseInfo = { .userID = 111, // 111: user id @@ -177,35 +109,42 @@ HWTEST_F(SetPermDialogCapTest, SetPermDialogCapAbnormalTest001, TestSize.Level1) */ HWTEST_F(SetPermDialogCapTest, SetPermDialogCapFuncTest001, TestSize.Level1) { + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.DISABLE_PERMISSION_DIALOG"); + MockHapToken mock("SetPermDialogCapAbnormalTest001", reqPerm, true); + uint64_t selfToken = GetSelfTokenID(); + LOGI(ATM_DOMAIN, ATM_TAG, "SetPermDialogCapFuncTest001"); - AccessTokenID tokenID = TestCommon::AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ(RET_SUCCESS, TestCommon::AllocTestHapToken(g_infoManager, g_policy, tokenIdEx)); + ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); HapBaseInfo hapBaseInfo = { - .userID = g_infoManagerTestInfoParms.userID, - .bundleName = g_infoManagerTestInfoParms.bundleName, - .instIndex = g_infoManagerTestInfoParms.instIndex, + .userID = g_infoManager.userID, + .bundleName = g_infoManager.bundleName, + .instIndex = g_infoManager.instIndex, }; std::vector permsList; PermissionListState tmp = { - .permissionName = g_infoManagerTestPolicyPrams.permStateList[0].permissionName, + .permissionName = g_policy.permStateList[0].permissionName, .state = PASS_OPER }; permsList.emplace_back(tmp); // test dialog is forbiddedn - ASSERT_EQ(0, AccessTokenKit::SetPermDialogCap(hapBaseInfo, true)); - SetSelfTokenID(tokenID); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::SetPermDialogCap(hapBaseInfo, true)); + ASSERT_EQ(RET_SUCCESS, SetSelfTokenID(tokenIdEx.tokenIDEx)); PermissionGrantInfo info; ASSERT_EQ(FORBIDDEN_OPER, AccessTokenKit::GetSelfPermissionsState(permsList, info)); - SetSelfTokenID(selfTokenId_); + ASSERT_EQ(RET_SUCCESS, SetSelfTokenID(selfToken)); // test dialog is not forbiddedn - ASSERT_EQ(0, AccessTokenKit::SetPermDialogCap(hapBaseInfo, false)); - SetSelfTokenID(tokenID); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::SetPermDialogCap(hapBaseInfo, false)); + ASSERT_EQ(RET_SUCCESS, SetSelfTokenID(tokenIdEx.tokenIDEx)); ASSERT_NE(FORBIDDEN_OPER, AccessTokenKit::GetSelfPermissionsState(permsList, info)); - SetSelfTokenID(selfTokenId_); + ASSERT_EQ(RET_SUCCESS, SetSelfTokenID(selfToken)); - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID)); } } // namespace AccessToken } // namespace Security diff --git a/interfaces/innerkits/accesstoken/test/unittest/HapAttributeTest/set_perm_dialog_cap_test.h b/interfaces/innerkits/accesstoken/test/unittest/PermisionDialogTest/set_perm_dialog_cap_test.h similarity index 97% rename from interfaces/innerkits/accesstoken/test/unittest/HapAttributeTest/set_perm_dialog_cap_test.h rename to interfaces/innerkits/accesstoken/test/unittest/PermisionDialogTest/set_perm_dialog_cap_test.h index d3e51868f60b4bff91a3454b9c4d2ca9081b8221..e466f1d661e0fca8c4dc6c22c2a4f5f6dfd10786 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/HapAttributeTest/set_perm_dialog_cap_test.h +++ b/interfaces/innerkits/accesstoken/test/unittest/PermisionDialogTest/set_perm_dialog_cap_test.h @@ -34,7 +34,6 @@ public: void TearDown(); void DeleteTestToken() const; AccessTokenID AllocTestToken(const HapInfoParams& hapInfo, const HapPolicyParams& hapPolicy) const; - uint64_t selfTokenId_; }; } // namespace AccessToken } // namespace Security diff --git a/interfaces/innerkits/accesstoken/test/unittest/PermissionsTest/clear_user_granted__permission_state_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/PermissionsTest/clear_user_granted__permission_state_test.cpp index 11e901037793827df485fea8c2cc9bf065219810..636cbcb4231dfc08b323bf09e4544e9b530e32cb 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/PermissionsTest/clear_user_granted__permission_state_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/PermissionsTest/clear_user_granted__permission_state_test.cpp @@ -21,6 +21,7 @@ #include "access_token_error.h" #include "accesstoken_common_log.h" #include "accesstoken_service_ipc_interface_code.h" +#include "test_common.h" #include "permission_grant_info.h" #include "permission_state_change_info_parcel.h" #include "string_ex.h" @@ -33,52 +34,50 @@ namespace OHOS { namespace Security { namespace AccessToken { namespace { -static AccessTokenID g_selfTokenId = 0; +static uint64_t g_selfTokenId = 0; static const std::string TEST_BUNDLE_NAME = "ohos"; static const unsigned int TEST_TOKENID_INVALID = 0; static const int CYCLE_TIMES = 100; static const int TEST_USER_ID = 0; static constexpr int32_t DEFAULT_API_VERSION = 8; -HapInfoParams g_infoManagerTestInfoParms = TestCommon::GetInfoManagerTestInfoParms(); -HapInfoParams g_infoManagerTestInfoParmsBak = g_infoManagerTestInfoParms; +HapInfoParams g_infoParms = { + .userID = 1, + .bundleName = "accesstoken_test", + .instIndex = 0, + .appIDDesc = "test3", + .apiVersion = 8, + .appDistributionType = "enterprise_mdm" +}; +static MockHapToken* g_mock = nullptr; }; void ClearUserGrantedPermissionStateTest::SetUpTestCase() { g_selfTokenId = GetSelfTokenID(); - - // clean up test cases - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, - TestCommon::GetTestPolicyParams()); - SetSelfTokenID(tokenIdEx.tokenIDEx); + TestCommon::SetTestEvironment(g_selfTokenId); + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.REVOKE_SENSITIVE_PERMISSIONS"); + g_mock = new (std::nothrow) MockHapToken("ClearUserGrantedPermissionStateTest", reqPerm); } void ClearUserGrantedPermissionStateTest::TearDownTestCase() { - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + TestCommon::DeleteTestHapToken(tokenID); - SetSelfTokenID(g_selfTokenId); + if (g_mock != nullptr) { + delete g_mock; + g_mock = nullptr; + } + EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId)); + TestCommon::ResetTestEvironment(); } void ClearUserGrantedPermissionStateTest::SetUp() { LOGI(ATM_DOMAIN, ATM_TAG, "SetUp ok."); - setuid(0); HapInfoParams info = { .userID = TEST_USER_ID, .bundleName = TEST_BUNDLE_NAME, @@ -91,14 +90,16 @@ void ClearUserGrantedPermissionStateTest::SetUp() .apl = APL_NORMAL, .domain = "domain" }; - TestCommon::TestPreparePermDefList(policy); TestCommon::TestPreparePermStateList(policy); - - AccessTokenKit::AllocHapToken(info, policy); + AccessTokenIDEx tokenIdEx = TestCommon::AllocAndGrantHapTokenByTest(info, policy); + EXPECT_NE(INVALID_TOKENID, tokenIdEx.tokenIdExStruct.tokenID); } void ClearUserGrantedPermissionStateTest::TearDown() { + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + TestCommon::DeleteTestHapToken(tokenID); } /** @@ -111,19 +112,16 @@ HWTEST_F(ClearUserGrantedPermissionStateTest, ClearUserGrantedPermissionStateFun { LOGI(ATM_DOMAIN, ATM_TAG, "ClearUserGrantedPermissionStateFuncTest001"); - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; ASSERT_NE(INVALID_TOKENID, tokenID); - int ret = AccessTokenKit::ClearUserGrantedPermissionState(tokenID); - ASSERT_EQ(RET_SUCCESS, ret); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::ClearUserGrantedPermissionState(tokenID)); - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.MICROPHONE", false); - ASSERT_EQ(PERMISSION_DENIED, ret); + ASSERT_EQ(PERMISSION_DENIED, AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.MICROPHONE", false)); - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.SET_WIFI_INFO", false); - ASSERT_EQ(PERMISSION_DENIED, ret); + ASSERT_EQ(PERMISSION_GRANTED, AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.SET_WIFI_INFO", false)); - ret = AccessTokenKit::DeleteToken(tokenID); - ASSERT_EQ(RET_SUCCESS, ret); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -135,18 +133,6 @@ HWTEST_F(ClearUserGrantedPermissionStateTest, ClearUserGrantedPermissionStateFun HWTEST_F(ClearUserGrantedPermissionStateTest, ClearUserGrantedPermissionStateFuncTest002, TestSize.Level0) { LOGI(ATM_DOMAIN, ATM_TAG, "ClearUserGrantedPermissionStateFuncTest002"); - - PermissionDef g_infoManagerTestPermDef1 = { - .permissionName = "ohos.permission.test1", - .bundleName = "accesstoken_test", - .grantMode = 1, - .availableLevel = APL_NORMAL, - .label = "label3", - .labelId = 1, - .description = "open the door", - .descriptionId = 1, - .availableType = MDM - }; OHOS::Security::AccessToken::PermissionStateFull infoManagerTestState1 = { .permissionName = "ohos.permission.CAMERA", .isGeneral = true, @@ -168,24 +154,25 @@ HWTEST_F(ClearUserGrantedPermissionStateTest, ClearUserGrantedPermissionStateFun .grantStatus = {OHOS::Security::AccessToken::PermissionState::PERMISSION_GRANTED}, .grantFlags = {PERMISSION_USER_FIXED} }; - OHOS::Security::AccessToken::HapPolicyParams infoManagerTestPolicyPrams = { + OHOS::Security::AccessToken::HapPolicyParams policyPrams = { .apl = OHOS::Security::AccessToken::ATokenAplEnum::APL_NORMAL, .domain = "test.domain", - .permList = {g_infoManagerTestPermDef1}, .permStateList = {infoManagerTestState1, infoManagerTestState2, infoManagerTestState3} }; - AccessTokenID tokenID = TestCommon::AllocTestToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams); + AccessTokenIDEx tokenIdEx = TestCommon::AllocAndGrantHapTokenByTest(g_infoParms, policyPrams); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; ASSERT_NE(INVALID_TOKENID, tokenID); ASSERT_EQ(RET_SUCCESS, AccessTokenKit::ClearUserGrantedPermissionState(tokenID)); + // PERMISSION_SYSTEM_FIXED, not clear permission ASSERT_EQ(PERMISSION_GRANTED, AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.CAMERA", false)); ASSERT_EQ(PERMISSION_GRANTED, AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.SEND_MESSAGES", false)); ASSERT_EQ(PERMISSION_DENIED, AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.RECEIVE_SMS", false)); - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -198,17 +185,15 @@ HWTEST_F(ClearUserGrantedPermissionStateTest, ClearUserGrantedPermissionStateAbn { LOGI(ATM_DOMAIN, ATM_TAG, "ClearUserGrantedPermissionStateAbnormalTest001"); - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; - int ret = AccessTokenKit::ClearUserGrantedPermissionState(TEST_TOKENID_INVALID); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); + ASSERT_EQ( + AccessTokenError::ERR_PARAM_INVALID, AccessTokenKit::ClearUserGrantedPermissionState(TEST_TOKENID_INVALID)); - ret = AccessTokenKit::DeleteToken(tokenID); - ASSERT_EQ(RET_SUCCESS, ret); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); - ret = AccessTokenKit::ClearUserGrantedPermissionState(tokenID); - ASSERT_EQ(RET_SUCCESS, ret); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::ClearUserGrantedPermissionState(tokenID)); } /** @@ -221,16 +206,14 @@ HWTEST_F(ClearUserGrantedPermissionStateTest, ClearUserGrantedPermissionStateSpe { LOGI(ATM_DOMAIN, ATM_TAG, "ClearUserGrantedPermissionStateSpecTets001"); - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; ASSERT_NE(INVALID_TOKENID, tokenID); for (int i = 0; i < CYCLE_TIMES; i++) { - int32_t ret = AccessTokenKit::ClearUserGrantedPermissionState(tokenID); - ASSERT_EQ(RET_SUCCESS, ret); - - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.MICROPHONE", false); - ASSERT_EQ(PERMISSION_DENIED, ret); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::ClearUserGrantedPermissionState(tokenID)); + ASSERT_EQ(PERMISSION_DENIED, AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.MICROPHONE", false)); } - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } } // namespace AccessToken } // namespace Security diff --git a/interfaces/innerkits/accesstoken/test/unittest/PermissionsTest/get_permission_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/PermissionsTest/get_permission_test.cpp index 2cd3614de4950d6281a70072b17bb54661467d45..69aa3bb99bc01e1dcf641daf73b585fd51fd599f 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/PermissionsTest/get_permission_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/PermissionsTest/get_permission_test.cpp @@ -33,33 +33,34 @@ namespace OHOS { namespace Security { namespace AccessToken { namespace { -static AccessTokenID g_selfTokenId = 0; +static uint64_t g_selfTokenId = 0; static const std::string TEST_BUNDLE_NAME = "ohos"; static const int INVALID_PERMNAME_LEN = 260; static const unsigned int TEST_TOKENID_INVALID = 0; static const int CYCLE_TIMES = 100; static const int TEST_USER_ID = 0; static constexpr int32_t DEFAULT_API_VERSION = 8; +static const std::string TEST_PERMISSION = "ohos.permission.ALPHA"; HapInfoParams g_infoManagerTestInfoParms = TestCommon::GetInfoManagerTestInfoParms(); HapPolicyParams g_infoManagerTestPolicyPrams = TestCommon::GetInfoManagerTestPolicyPrams(); +HapInfoParams g_infoManager = { + .userID = 1, + .bundleName = "accesstoken_test", + .instIndex = 0, + .appIDDesc = "test2", + .apiVersion = 8 // 8: api version +}; } void GetPermissionTest::SetUpTestCase() { g_selfTokenId = GetSelfTokenID(); + TestCommon::SetTestEvironment(g_selfTokenId); // clean up test cases - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, - TestCommon::GetTestPolicyParams()); - SetSelfTokenID(tokenIdEx.tokenIDEx); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + TestCommon::DeleteTestHapToken(tokenID); } void GetPermissionTest::TearDownTestCase() @@ -67,19 +68,14 @@ void GetPermissionTest::TearDownTestCase() AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); AccessTokenKit::DeleteToken(tokenID); - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - SetSelfTokenID(g_selfTokenId); + EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId)); + TestCommon::ResetTestEvironment(); } void GetPermissionTest::SetUp() { LOGI(ATM_DOMAIN, ATM_TAG, "SetUp ok."); - setuid(0); HapInfoParams info = { .userID = TEST_USER_ID, .bundleName = TEST_BUNDLE_NAME, @@ -92,46 +88,77 @@ void GetPermissionTest::SetUp() .apl = APL_NORMAL, .domain = "domain" }; - TestCommon::TestPreparePermDefList(policy); TestCommon::TestPreparePermStateList(policy); - - AccessTokenKit::AllocHapToken(info, policy); + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ(RET_SUCCESS, TestCommon::AllocTestHapToken(info, policy, tokenIdEx)); + ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIdExStruct.tokenID); } void GetPermissionTest::TearDown() { + AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenKit::DeleteToken(tokenID); } /** * @tc.name: GetPermissionUsedTypeAbnormalTest001 - * @tc.desc: Get hap permission visit type return invalid. + * @tc.desc: call GetPermissionUsedType by shell token(permission denied). * @tc.type: FUNC * @tc.require: */ HWTEST_F(GetPermissionTest, GetPermissionUsedTypeAbnormalTest001, TestSize.Level1) +{ + LOGI(ATM_DOMAIN, ATM_TAG, "GetPermissionUsedTypeAbnormalTest001"); + std::string permisson = "ohos.permission.CAMERA"; +#ifndef ATM_BUILD_VARIANT_USER_ENABLE + // caller is not native, IsPrivilegedCalling return false(uid != accesstoken_uid) + int32_t selfUid = getuid(); + setuid(1); + EXPECT_EQ(PermUsedTypeEnum::INVALID_USED_TYPE, AccessTokenKit::GetPermissionUsedType(g_selfTokenId, permisson)); + setuid(selfUid); +#else + // caller is not native, IsPrivilegedCalling return false + EXPECT_EQ(PermUsedTypeEnum::INVALID_USED_TYPE, + AccessTokenKit::GetPermissionUsedType(g_selfTokenId, permisson)); +#endif +} + +/** + * @tc.name: GetPermissionUsedTypeAbnormalTest002 + * @tc.desc: Get hap permission visit type return invalid. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(GetPermissionTest, GetPermissionUsedTypeAbnormalTest002, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "GetPermissionUsedTypeAbnormalTest001"); std::string accessBluetooth = "ohos.permission.ACCESS_BLUETOOTH"; - - EXPECT_EQ(PermUsedTypeEnum::INVALID_USED_TYPE, - AccessTokenKit::GetPermissionUsedType(g_selfTokenId, accessBluetooth)); - AccessTokenID tokenID = TestCommon::AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); + std::vector reqPerm; + reqPerm.emplace_back(accessBluetooth); + MockHapToken mockHap("GetPermissionUsedTypeAbnormalTest001", reqPerm, true); + AccessTokenID tokenID = GetSelfTokenID(); // get hap tokenId ASSERT_NE(INVALID_TOKENID, tokenID); - EXPECT_EQ(PermUsedTypeEnum::INVALID_USED_TYPE, - AccessTokenKit::GetPermissionUsedType(0, accessBluetooth)); + MockNativeToken mock("accesstoken_service"); // set native for self - EXPECT_EQ(PermUsedTypeEnum::INVALID_USED_TYPE, - AccessTokenKit::GetPermissionUsedType(tokenID, "ohos.permission.ACCELEROMETER")); + // token is not hap + EXPECT_EQ( + PermUsedTypeEnum::INVALID_USED_TYPE, AccessTokenKit::GetPermissionUsedType(g_selfTokenId, accessBluetooth)); - EXPECT_EQ(PermUsedTypeEnum::INVALID_USED_TYPE, - AccessTokenKit::GetPermissionUsedType(tokenID, "ohos.permission.xxxxx")); + // invalid tokenid + EXPECT_EQ(PermUsedTypeEnum::INVALID_USED_TYPE, AccessTokenKit::GetPermissionUsedType(0, accessBluetooth)); + // permission is not reuqest EXPECT_EQ(PermUsedTypeEnum::INVALID_USED_TYPE, - AccessTokenKit::GetPermissionUsedType(tokenID, accessBluetooth)); + AccessTokenKit::GetPermissionUsedType(tokenID, "ohos.permission.ACCELEROMETER")); + + // permission is not defined + EXPECT_EQ( + PermUsedTypeEnum::INVALID_USED_TYPE, AccessTokenKit::GetPermissionUsedType(tokenID, "ohos.permission.test")); - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); + // permission is request, but not grant + EXPECT_EQ(PermUsedTypeEnum::INVALID_USED_TYPE, AccessTokenKit::GetPermissionUsedType(tokenID, accessBluetooth)); } /** @@ -173,21 +200,15 @@ HWTEST_F(GetPermissionTest, GetPermissionUsedTypeFuncTest001, TestSize.Level1) .domain = "test.domain3", .permStateList = {testState1, testState2, testState3} }; - AccessTokenID tokenID = TestCommon::AllocTestToken(g_infoManagerTestInfoParms, testPolicyPrams); + AccessTokenIDEx tokenIdEx = TestCommon::AllocAndGrantHapTokenByTest(g_infoManager, testPolicyPrams); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; ASSERT_NE(INVALID_TOKENID, tokenID); - EXPECT_EQ(PermUsedTypeEnum::SEC_COMPONENT_TYPE, - AccessTokenKit::GetPermissionUsedType(tokenID, accessBluetooth)); - + MockNativeToken mock("accesstoken_service"); // set native for self + EXPECT_EQ(PermUsedTypeEnum::SEC_COMPONENT_TYPE, AccessTokenKit::GetPermissionUsedType(tokenID, accessBluetooth)); EXPECT_EQ(PermUsedTypeEnum::NORMAL_TYPE, AccessTokenKit::GetPermissionUsedType(tokenID, sendMessages)); - int32_t selfUid = getuid(); - EXPECT_EQ(0, SetSelfTokenID(tokenID)); - setuid(1); - EXPECT_EQ(PermUsedTypeEnum::INVALID_USED_TYPE, - AccessTokenKit::GetPermissionUsedType(tokenID, writeCalendar)); - setuid(selfUid); - ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -233,8 +254,12 @@ HWTEST_F(GetPermissionTest, GetDefPermissionFuncTest001, TestSize.Level1) HWTEST_F(GetPermissionTest, GetReqPermissionsFuncTest001, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "GetReqPermissionsFuncTest001"); + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.GET_SENSITIVE_PERMISSIONS"); + MockHapToken mockHap("GetReqPermissionsFuncTest001", reqPerm, true); - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; ASSERT_NE(INVALID_TOKENID, tokenID); std::vector permStatList; int res = AccessTokenKit::GetReqPermissions(tokenID, permStatList, false); @@ -244,8 +269,6 @@ HWTEST_F(GetPermissionTest, GetReqPermissionsFuncTest001, TestSize.Level1) res = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.MICROPHONE", false); ASSERT_EQ(res, permStatList[0].grantStatus[0]); - - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); } /** @@ -257,8 +280,12 @@ HWTEST_F(GetPermissionTest, GetReqPermissionsFuncTest001, TestSize.Level1) HWTEST_F(GetPermissionTest, GetReqPermissionsFuncTest002, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "GetReqPermissionsFuncTest002"); + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.GET_SENSITIVE_PERMISSIONS"); + MockHapToken mockHap("GetReqPermissionsFuncTest002", reqPerm, true); - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; ASSERT_NE(INVALID_TOKENID, tokenID); std::vector permStatList; int ret = AccessTokenKit::GetReqPermissions(tokenID, permStatList, true); @@ -268,8 +295,6 @@ HWTEST_F(GetPermissionTest, GetReqPermissionsFuncTest002, TestSize.Level1) ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.SET_WIFI_INFO", false); ASSERT_EQ(ret, permStatList[0].grantStatus[0]); - - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); } /** @@ -281,14 +306,17 @@ HWTEST_F(GetPermissionTest, GetReqPermissionsFuncTest002, TestSize.Level1) HWTEST_F(GetPermissionTest, GetReqPermissionsFuncTest003, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "GetReqPermissionsFuncTest003"); + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.GET_SENSITIVE_PERMISSIONS"); + MockHapToken mockHap("GetReqPermissionsFuncTest003", reqPerm, true); - AccessTokenIDEx tokenIdEx = AccessTokenKit::GetHapTokenIDEx(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; ASSERT_NE(INVALID_TOKENID, tokenID); - HapTokenInfo hapInfo; - int ret = AccessTokenKit::GetHapTokenInfo(tokenID, hapInfo); - ASSERT_EQ(RET_SUCCESS, ret); + std::vector permStatList; + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GetReqPermissions(tokenID, permStatList, false)); + ASSERT_NE(static_cast(0), permStatList.size()); HapPolicyParams policy = { .apl = APL_NORMAL, @@ -296,23 +324,48 @@ HWTEST_F(GetPermissionTest, GetReqPermissionsFuncTest003, TestSize.Level1) }; policy.permStateList.clear(); UpdateHapInfoParams info; - info.appIDDesc = g_infoManagerTestInfoParms.appIDDesc; + info.appIDDesc = g_infoManager.appIDDesc; info.apiVersion = DEFAULT_API_VERSION; info.isSystemApp = false; - ret = AccessTokenKit::UpdateHapToken(tokenIdEx, info, policy); - ASSERT_EQ(RET_SUCCESS, ret); + { + MockNativeToken mock1("foundation"); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UpdateHapToken(tokenIdEx, info, policy)); + } std::vector permStatUserList; - ret = AccessTokenKit::GetReqPermissions(tokenID, permStatUserList, false); - ASSERT_EQ(RET_SUCCESS, ret); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GetReqPermissions(tokenID, permStatUserList, false)); ASSERT_EQ(static_cast(0), permStatUserList.size()); std::vector permStatSystemList; - ret = AccessTokenKit::GetReqPermissions(tokenID, permStatSystemList, true); - ASSERT_EQ(RET_SUCCESS, ret); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GetReqPermissions(tokenID, permStatSystemList, true)); ASSERT_EQ(static_cast(0), permStatSystemList.size()); +} + +/** + * @tc.name: GetReqPermissionsFuncTest004 + * @tc.desc: GetReqPermissions call failure. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(GetPermissionTest, GetReqPermissionsFuncTest004, TestSize.Level0) +{ + int32_t selfUid = getuid(); + std::vector permStatList; + { + // mock native token with no permission + MockNativeToken mock("accesstoken_service"); + setuid(1); + ASSERT_EQ(ERR_PERMISSION_DENIED, AccessTokenKit::GetReqPermissions(GetSelfTokenID(), permStatList, false)); + } - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); + setuid(selfUid); + { + // mock hap token whit non system app + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.GET_SENSITIVE_PERMISSIONS"); + MockHapToken mock("GetReqPermissionsFuncTest004", reqPerm, false); + ASSERT_EQ(ERR_NOT_SYSTEM_APP, AccessTokenKit::GetReqPermissions(GetSelfTokenID(), permStatList, false)); + } } /** @@ -324,15 +377,19 @@ HWTEST_F(GetPermissionTest, GetReqPermissionsFuncTest003, TestSize.Level1) HWTEST_F(GetPermissionTest, GetReqPermissionsAbnormalTest001, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "GetReqPermissionsAbnormalTest001"); + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.GET_SENSITIVE_PERMISSIONS"); + MockHapToken mockHap("GetReqPermissionsFuncTest002", reqPerm, true); - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; ASSERT_NE(INVALID_TOKENID, tokenID); std::vector permStatList; int ret = AccessTokenKit::GetReqPermissions(TEST_TOKENID_INVALID, permStatList, false); ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); - AccessTokenKit::DeleteToken(tokenID); + TestCommon::DeleteTestHapToken(tokenID); ret = AccessTokenKit::GetReqPermissions(tokenID, permStatList, false); ASSERT_EQ(ERR_TOKENID_NOT_EXIST, ret); @@ -348,8 +405,12 @@ HWTEST_F(GetPermissionTest, GetReqPermissionsAbnormalTest001, TestSize.Level1) HWTEST_F(GetPermissionTest, GetReqPermissionsSpecTest001, TestSize.Level0) { LOGI(ATM_DOMAIN, ATM_TAG, "GetReqPermissionsSpecTest001"); + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.GET_SENSITIVE_PERMISSIONS"); + MockHapToken mockHap("GetReqPermissionsFuncTest002", reqPerm, true); - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; ASSERT_NE(INVALID_TOKENID, tokenID); for (int i = 0; i < CYCLE_TIMES; i++) { std::vector permStatList; @@ -358,69 +419,105 @@ HWTEST_F(GetPermissionTest, GetReqPermissionsSpecTest001, TestSize.Level0) ASSERT_EQ(static_cast(1), permStatList.size()); ASSERT_EQ("ohos.permission.MICROPHONE", permStatList[0].permissionName); } - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); } /** - * @tc.name: GetReqPermissions001 - * @tc.desc: GetReqPermissions call failure. + * @tc.name: GetPermissionManagerInfoFuncTest001 + * @tc.desc: * @tc.type: FUNC - * @tc.require: Issue Number + * @tc.require: */ -HWTEST_F(GetPermissionTest, GetReqPermissions001, TestSize.Level0) +HWTEST_F(GetPermissionTest, GetPermissionManagerInfoFuncTest001, TestSize.Level1) { - AccessTokenIDEx tokenIdEx = {0}; - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "test.GetReqPermissions", - .permList = {}, - .permStateList = {} - }; - HapInfoParams info = { - .userID = 100, - .bundleName = "test.GetReqPermissions.normal", - .instIndex = 0, - .appIDDesc = "test3", - .apiVersion = DEFAULT_API_VERSION, - .isSystemApp = false - }; + LOGI(ATM_DOMAIN, ATM_TAG, "GetPermissionManagerInfoFuncTest001"); - tokenIdEx = AccessTokenKit::AllocHapToken(info, policy); - AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); - int32_t selfUid = getuid(); + PermissionGrantInfo info; + AccessTokenKit::GetPermissionManagerInfo(info); + ASSERT_EQ(false, info.grantBundleName.empty()); +} - setuid(0); - std::vector permStatList; - EXPECT_EQ(0, SetSelfTokenID(TestCommon::GetNativeToken("GetReqPermissions", nullptr, 0))); - setuid(1); - int32_t ret = AccessTokenKit::GetReqPermissions(tokenID, permStatList, false); - ASSERT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, ret); +/** + * @tc.name: GetTokenIDByUserID001 + * @tc.desc: Get token id by user id. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(GetPermissionTest, GetTokenIDByUserID001, TestSize.Level1) +{ + MockNativeToken mock("accesstoken_service"); + int32_t userID = -1; + std::unordered_set tokenIdList; + int32_t ret = AccessTokenKit::GetTokenIDByUserID(userID, tokenIdList); + EXPECT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); + + userID = 100; + ret = AccessTokenKit::GetTokenIDByUserID(userID, tokenIdList); + EXPECT_EQ(RET_SUCCESS, ret); + EXPECT_NE(static_cast(0), tokenIdList.size()); +} - setuid(0); - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); - ret = AccessTokenKit::GetReqPermissions(tokenID, permStatList, false); - ASSERT_EQ(ERR_NOT_SYSTEM_APP, ret); +/** + * @tc.name: ReloadNativeTokenInfo001 + * @tc.desc: test ReloadNativeTokenInfo. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(GetPermissionTest, ReloadNativeTokenInfo001, TestSize.Level1) +{ + int32_t ret = AccessTokenKit::ReloadNativeTokenInfo(); + ASSERT_EQ(RET_SUCCESS, ret); +} - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); - setuid(selfUid); - ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); +#ifndef ATM_BUILD_VARIANT_USER_ENABLE +uint64_t GetNativeTokenTest(const char *processName, const char **perms, int32_t permNum) +{ + uint64_t tokenId; + NativeTokenInfoParams infoInstance = { + .dcapsNum = 0, + .permsNum = permNum, + .aclsNum = 0, + .dcaps = nullptr, + .perms = perms, + .acls = nullptr, + .aplStr = "system_core", + .processName = processName, + }; + + tokenId = GetAccessTokenId(&infoInstance); + AccessTokenKit::ReloadNativeTokenInfo(); + return tokenId; } /** - * @tc.name: GetPermissionManagerInfoFuncTest001 - * @tc.desc: + * @tc.name: ReloadNativeTokenInfo002 + * @tc.desc: ReloadNativeTokenInfo with same bundlename twicely. * @tc.type: FUNC - * @tc.require: + * @tc.require: Issue Number */ -HWTEST_F(GetPermissionTest, GetPermissionManagerInfoFuncTest001, TestSize.Level1) +HWTEST_F(GetPermissionTest, ReloadNativeTokenInfo002, TestSize.Level1) { - LOGI(ATM_DOMAIN, ATM_TAG, "GetPermissionManagerInfoFuncTest001"); - - PermissionGrantInfo info; - AccessTokenKit::GetPermissionManagerInfo(info); - ASSERT_EQ(false, info.grantBundleName.empty()); + const char **perms = new const char *[1]; + perms[0] = "ohos.permission.MANAGE_HAP_TOKENID"; + uint64_t token1 = GetNativeTokenTest("TestCase_core", perms, 1); + ASSERT_NE(INVALID_TOKENID, token1); + ASSERT_EQ( + PERMISSION_GRANTED, AccessTokenKit::VerifyAccessToken(token1, "ohos.permission.MANAGE_HAP_TOKENID", false)); + + uint64_t token2 = GetNativeTokenTest("TestCase_core", nullptr, 0); + ASSERT_NE(INVALID_TOKENID, token2); + + ASSERT_EQ(token1, token2); + ASSERT_EQ( + PERMISSION_DENIED, AccessTokenKit::VerifyAccessToken(token2, "ohos.permission.MANAGE_HAP_TOKENID", false)); + + uint64_t token3 = GetNativeTokenTest("TestCase_core", perms, 1); + ASSERT_NE(INVALID_TOKENID, token3); + + ASSERT_EQ(token1, token3); + ASSERT_EQ( + PERMISSION_GRANTED, AccessTokenKit::VerifyAccessToken(token3, "ohos.permission.MANAGE_HAP_TOKENID", false)); } +#endif /** * @tc.name: GetKernelPermissionTest001 @@ -430,22 +527,21 @@ HWTEST_F(GetPermissionTest, GetPermissionManagerInfoFuncTest001, TestSize.Level1 */ HWTEST_F(GetPermissionTest, GetKernelPermissionTest001, TestSize.Level1) { - setuid(1); std::vector kernelPermList; - int32_t ret = AccessTokenKit::GetKernelPermissions(123, kernelPermList); - EXPECT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, ret); - setuid(0); - - SetSelfTokenID(g_selfTokenId); - ret = AccessTokenKit::GetKernelPermissions(123, kernelPermList); - EXPECT_EQ(AccessTokenError::ERR_TOKEN_INVALID, ret); + { + // shell process， uid != 0 + MockNativeToken mock("hdcd"); // set shell for self + setuid(1); + EXPECT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, AccessTokenKit::GetKernelPermissions(123, kernelPermList)); + setuid(0); + } - ret = AccessTokenKit::GetKernelPermissions(123, kernelPermList); - EXPECT_EQ(AccessTokenError::ERR_TOKEN_INVALID, ret); + // native process + MockNativeToken mock("accesstoken_service"); + EXPECT_EQ(AccessTokenError::ERR_TOKEN_INVALID, AccessTokenKit::GetKernelPermissions(123, kernelPermList)); AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ret = AccessTokenKit::GetKernelPermissions(tokenID, kernelPermList); - EXPECT_EQ(RET_SUCCESS, ret); + EXPECT_EQ(RET_SUCCESS, AccessTokenKit::GetKernelPermissions(tokenID, kernelPermList)); EXPECT_EQ(0, kernelPermList.size()); } @@ -457,22 +553,28 @@ HWTEST_F(GetPermissionTest, GetKernelPermissionTest001, TestSize.Level1) */ HWTEST_F(GetPermissionTest, GetReqPermissionByNameTest001, TestSize.Level1) { - setuid(1); std::string value; - int32_t ret = AccessTokenKit::GetReqPermissionByName(123, "ohos.permission.test1", value); - EXPECT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, ret); - setuid(0); + std::vector kernelPermList; + { + // shell process， uid != 0 + MockNativeToken mock("hdcd"); // set shell for self + setuid(1); + EXPECT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, + AccessTokenKit::GetReqPermissionByName(123, "ohos.permission.test1", value)); + setuid(0); + } - SetSelfTokenID(g_selfTokenId); - ret = AccessTokenKit::GetReqPermissionByName(123, "ohos.permission.test1", value); - EXPECT_EQ(AccessTokenError::ERR_TOKEN_INVALID, ret); + // native process， uid != 0 + MockNativeToken mock("accesstoken_service"); + EXPECT_EQ(AccessTokenError::ERR_TOKEN_INVALID, + AccessTokenKit::GetReqPermissionByName(123, "ohos.permission.test1", value)); AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ret = AccessTokenKit::GetReqPermissionByName(tokenID, "ohos.permission.test1", value); - EXPECT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, ret); + EXPECT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, + AccessTokenKit::GetReqPermissionByName(tokenID, "ohos.permission.test1", value)); - ret = AccessTokenKit::GetReqPermissionByName(tokenID, "ohos.permission.MANAGE_HAP_TOKENID", value); - EXPECT_EQ(AccessTokenError::ERR_PERMISSION_WITHOUT_VALUE, ret); + EXPECT_EQ(AccessTokenError::ERR_PERMISSION_WITHOUT_VALUE, + AccessTokenKit::GetReqPermissionByName(tokenID, "ohos.permission.MANAGE_HAP_TOKENID", value)); } } // namespace AccessToken } // namespace Security diff --git a/interfaces/innerkits/accesstoken/test/unittest/PermissionsTest/grant_permission_for_specified_time_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/PermissionsTest/grant_permission_for_specified_time_test.cpp index 969f481fb57b28e40c76f83c9182c809ce421b20..892426db406c8899f9d5bc8653709733ea8522be 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/PermissionsTest/grant_permission_for_specified_time_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/PermissionsTest/grant_permission_for_specified_time_test.cpp @@ -25,10 +25,10 @@ namespace OHOS { namespace Security { namespace AccessToken { namespace { -static const int32_t INDEX_ZERO = 0; -static AccessTokenID g_selfTokenId = 0; +static uint64_t g_selfTokenId = 0; static int32_t g_selfUid; static std::string SHORT_TEMP_PERMISSION = "ohos.permission.SHORT_TERM_WRITE_IMAGEVIDEO"; +static MockHapToken* g_mock = nullptr; static PermissionStateFull g_permiState = { .permissionName = SHORT_TEMP_PERMISSION, .isGeneral = true, @@ -52,17 +52,6 @@ static HapInfoParams g_infoParms = { }; } -static void NativeTokenGet() -{ - uint64_t tokenID; - const char **perms = new const char *[1]; // 1: array size - perms[INDEX_ZERO] = "ohos.permission.DISTRIBUTED_DATASYNC"; - - tokenID = TestCommon::GetNativeToken("GrantPermissionForSpecifiedTimeTest", perms, 1); // 1: array size - EXPECT_EQ(0, SetSelfTokenID(tokenID)); - delete[] perms; -} - using namespace testing::ext; void GrantPermissionForSpecifiedTimeTest::SetUpTestCase() @@ -70,32 +59,42 @@ void GrantPermissionForSpecifiedTimeTest::SetUpTestCase() g_selfTokenId = GetSelfTokenID(); g_selfUid = getuid(); - NativeTokenGet(); + TestCommon::SetTestEvironment(g_selfTokenId); + + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.GRANT_SHORT_TERM_WRITE_MEDIAVIDEO"); + g_mock = new (std::nothrow) MockHapToken("GrantPermissionForSpecifiedTimeTest", reqPerm); } void GrantPermissionForSpecifiedTimeTest::TearDownTestCase() { + if (g_mock != nullptr) { + delete g_mock; + g_mock = nullptr; + } setuid(g_selfUid); EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId)); + TestCommon::ResetTestEvironment(); } void GrantPermissionForSpecifiedTimeTest::SetUp() { setuid(0); - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoParms.userID, - g_infoParms.bundleName, - g_infoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle( + g_infoParms.userID, g_infoParms.bundleName, g_infoParms.instIndex); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + TestCommon::DeleteTestHapToken(tokenID); - AccessTokenKit::AllocHapToken(g_infoParms, g_policyPrams); + ASSERT_EQ(RET_SUCCESS, TestCommon::AllocTestHapToken(g_infoParms, g_policyPrams, tokenIdEx)); + EXPECT_NE(0, tokenIdEx.tokenIdExStruct.tokenID); } void GrantPermissionForSpecifiedTimeTest::TearDown() { - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoParms.userID, - g_infoParms.bundleName, - g_infoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle( + g_infoParms.userID, g_infoParms.bundleName, g_infoParms.instIndex); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + TestCommon::DeleteTestHapToken(tokenID); } /** @@ -149,10 +148,9 @@ HWTEST_F(GrantPermissionForSpecifiedTimeTest, GrantPermissionForSpecifiedTimeAbn HapInfoParams infoParms = g_infoParms; policyPrams.permStateList.clear(); - AccessTokenKit::AllocHapToken(infoParms, policyPrams); - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(infoParms.userID, - infoParms.bundleName, - infoParms.instIndex); + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ(RET_SUCCESS, TestCommon::AllocTestHapToken(infoParms, policyPrams, tokenIdEx)); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; ASSERT_NE(INVALID_TOKENID, tokenID); uint32_t onceTime = 10; // 10: 10s @@ -169,9 +167,9 @@ HWTEST_F(GrantPermissionForSpecifiedTimeTest, GrantPermissionForSpecifiedTimeAbn HWTEST_F(GrantPermissionForSpecifiedTimeTest, GrantPermissionForSpecifiedTimeAbnormalTest003, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "GrantPermissionForSpecifiedTimeAbnormalTest003"); - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoParms.userID, - g_infoParms.bundleName, - g_infoParms.instIndex); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle( + g_infoParms.userID, g_infoParms.bundleName, g_infoParms.instIndex); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; ASSERT_NE(INVALID_TOKENID, tokenID); uint32_t onceTime = 10; // 10: 10s std::string permission = "ohos.permission.CAMERA"; @@ -189,6 +187,8 @@ HWTEST_F(GrantPermissionForSpecifiedTimeTest, GrantPermissionForSpecifiedTimeAbn HWTEST_F(GrantPermissionForSpecifiedTimeTest, GrantPermissionForSpecifiedTimeAbnormalTest004, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "GrantPermissionForSpecifiedTimeAbnormalTest004"); + uint64_t selfTokenId = GetSelfTokenID(); + SetSelfTokenID(g_selfTokenId); setuid(1234); AccessTokenID tokenId = 123; std::string permission = "permission"; @@ -196,6 +196,7 @@ HWTEST_F(GrantPermissionForSpecifiedTimeTest, GrantPermissionForSpecifiedTimeAbn ASSERT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, AccessTokenKit::GrantPermissionForSpecifiedTime(tokenId, permission, onceTime)); setuid(g_selfUid); + SetSelfTokenID(selfTokenId); } /** @@ -208,9 +209,9 @@ HWTEST_F(GrantPermissionForSpecifiedTimeTest, GrantPermissionForSpecifiedTimeAbn HWTEST_F(GrantPermissionForSpecifiedTimeTest, GrantPermissionForSpecifiedTimeSpecsTest001, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "GrantPermissionForSpecifiedTimeSpecsTest001"); - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoParms.userID, - g_infoParms.bundleName, - g_infoParms.instIndex); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle( + g_infoParms.userID, g_infoParms.bundleName, g_infoParms.instIndex); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; ASSERT_NE(INVALID_TOKENID, tokenID); uint32_t onceTime = 2; @@ -235,9 +236,9 @@ HWTEST_F(GrantPermissionForSpecifiedTimeTest, GrantPermissionForSpecifiedTimeSpe HWTEST_F(GrantPermissionForSpecifiedTimeTest, GrantPermissionForSpecifiedTimeSpecsTest002, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "GrantPermissionForSpecifiedTimeSpecsTest002"); - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoParms.userID, - g_infoParms.bundleName, - g_infoParms.instIndex); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle( + g_infoParms.userID, g_infoParms.bundleName, g_infoParms.instIndex); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; ASSERT_NE(INVALID_TOKENID, tokenID); uint32_t onceTime = 3; diff --git a/interfaces/innerkits/accesstoken/test/unittest/PermissionsTest/grant_permission_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/PermissionsTest/grant_permission_test.cpp index cfe154f4e6d745f77f0c76dbbc0ee5cd5e506d20..f9b5774fb101680003ba35440a3f84ef14e331f4 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/PermissionsTest/grant_permission_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/PermissionsTest/grant_permission_test.cpp @@ -33,57 +33,34 @@ namespace OHOS { namespace Security { namespace AccessToken { namespace { -static AccessTokenID g_selfTokenId = 0; +static uint64_t g_selfTokenId = 0; static const std::string TEST_BUNDLE_NAME = "ohos"; static const int INVALID_PERMNAME_LEN = 260; static const unsigned int TEST_TOKENID_INVALID = 0; static const int CYCLE_TIMES = 100; static const int TEST_USER_ID = 0; static constexpr int32_t DEFAULT_API_VERSION = 8; -HapPolicyParams g_infoManagerTestPolicyPrams = TestCommon::GetInfoManagerTestPolicyPrams(); -HapInfoParams g_infoManagerTestSystemInfoParms = TestCommon::GetInfoManagerTestSystemInfoParms(); -HapInfoParams g_infoManagerTestNormalInfoParms = TestCommon::GetInfoManagerTestNormalInfoParms(); }; void GrantPermissionTest::SetUpTestCase() { g_selfTokenId = GetSelfTokenID(); + TestCommon::SetTestEvironment(g_selfTokenId); // clean up test cases - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestNormalInfoParms.userID, - g_infoManagerTestNormalInfoParms.bundleName, - g_infoManagerTestNormalInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestSystemInfoParms.userID, - g_infoManagerTestSystemInfoParms.bundleName, - g_infoManagerTestSystemInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestSystemInfoParms, - TestCommon::GetTestPolicyParams()); - SetSelfTokenID(tokenIdEx.tokenIDEx); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + TestCommon::DeleteTestHapToken(tokenID); } void GrantPermissionTest::TearDownTestCase() { - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestNormalInfoParms.userID, - g_infoManagerTestNormalInfoParms.bundleName, - g_infoManagerTestNormalInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestSystemInfoParms.userID, - g_infoManagerTestSystemInfoParms.bundleName, - g_infoManagerTestSystemInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + TestCommon::DeleteTestHapToken(tokenID); SetSelfTokenID(g_selfTokenId); + TestCommon::ResetTestEvironment(); } void GrantPermissionTest::SetUp() @@ -95,22 +72,41 @@ void GrantPermissionTest::SetUp() .userID = TEST_USER_ID, .bundleName = TEST_BUNDLE_NAME, .instIndex = 0, - .appIDDesc = "appIDDesc", + .appIDDesc = "GrantPermissionTest", .apiVersion = DEFAULT_API_VERSION }; + PermissionStateFull permStatMicro = { + .permissionName = "ohos.permission.MICROPHONE", + .isGeneral = true, + .resDeviceID = {"device3"}, + .grantStatus = {PermissionState::PERMISSION_DENIED}, + .grantFlags = {PermissionFlag::PERMISSION_USER_SET} + }; + PermissionStateFull permStatCam = { + .permissionName = "ohos.permission.CAMERA", + .isGeneral = true, + .resDeviceID = {"device3"}, + .grantStatus = {PermissionState::PERMISSION_GRANTED}, + .grantFlags = {PermissionFlag::PERMISSION_USER_FIXED} + }; HapPolicyParams policy = { .apl = APL_NORMAL, - .domain = "domain" + .domain = "GrantPermissionTest", + .permStateList = { permStatMicro, permStatCam }, }; - TestCommon::TestPreparePermDefList(policy); - TestCommon::TestPreparePermStateList(policy); - AccessTokenKit::AllocHapToken(info, policy); + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ(RET_SUCCESS, TestCommon::AllocTestHapToken(info, policy, tokenIdEx)); + AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(tokenId, INVALID_TOKENID); } void GrantPermissionTest::TearDown() { + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + TestCommon::DeleteTestHapToken(tokenID); } /** @@ -122,8 +118,12 @@ void GrantPermissionTest::TearDown() HWTEST_F(GrantPermissionTest, GrantPermissionFuncTest001, TestSize.Level0) { LOGI(ATM_DOMAIN, ATM_TAG, "GrantPermissionFuncTest001"); + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.GRANT_SENSITIVE_PERMISSIONS"); + MockHapToken mock("GrantPermissionFuncTest001", reqPerm); - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; ASSERT_NE(INVALID_TOKENID, tokenID); int ret = AccessTokenKit::GrantPermission(tokenID, "ohos.permission.MICROPHONE", PERMISSION_USER_FIXED); ASSERT_EQ(RET_SUCCESS, ret); @@ -131,13 +131,13 @@ HWTEST_F(GrantPermissionTest, GrantPermissionFuncTest001, TestSize.Level0) ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.MICROPHONE", false); ASSERT_EQ(PERMISSION_GRANTED, ret); - ret = AccessTokenKit::GrantPermission(tokenID, "ohos.permission.SET_WIFI_INFO", PERMISSION_USER_FIXED); + ret = AccessTokenKit::GrantPermission(tokenID, "ohos.permission.CAMERA", PERMISSION_USER_FIXED); ASSERT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.MICROPHONE", false); + ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.CAMERA", false); ASSERT_EQ(PERMISSION_GRANTED, ret); - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -149,8 +149,12 @@ HWTEST_F(GrantPermissionTest, GrantPermissionFuncTest001, TestSize.Level0) HWTEST_F(GrantPermissionTest, GrantPermissionAbnormalTest001, TestSize.Level0) { LOGI(ATM_DOMAIN, ATM_TAG, "GrantPermissionAbnormalTest001"); + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.GRANT_SENSITIVE_PERMISSIONS"); + MockHapToken mock("GrantPermissionAbnormalTest001", reqPerm); - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; ASSERT_NE(INVALID_TOKENID, tokenID); int ret = AccessTokenKit::GrantPermission(tokenID, "ohos.permission.GAMMA", PERMISSION_USER_FIXED); @@ -163,11 +167,10 @@ HWTEST_F(GrantPermissionTest, GrantPermissionAbnormalTest001, TestSize.Level0) ret = AccessTokenKit::GrantPermission(tokenID, invalidPerm, PERMISSION_USER_FIXED); ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); - ret = AccessTokenKit::GrantPermission(TEST_TOKENID_INVALID, "ohos.permission.BETA", PERMISSION_USER_FIXED); + ret = AccessTokenKit::GrantPermission(TEST_TOKENID_INVALID, "ohos.permission.MICROPHONE", PERMISSION_USER_FIXED); ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); - ret = AccessTokenKit::DeleteToken(tokenID); - ASSERT_EQ(RET_SUCCESS, ret); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); ret = AccessTokenKit::GrantPermission(tokenID, "ohos.permission.BETA", PERMISSION_USER_FIXED); ASSERT_EQ(ERR_PERMISSION_NOT_EXIST, ret); @@ -182,13 +185,18 @@ HWTEST_F(GrantPermissionTest, GrantPermissionAbnormalTest001, TestSize.Level0) HWTEST_F(GrantPermissionTest, GrantPermissionAbnormalTest002, TestSize.Level0) { LOGI(ATM_DOMAIN, ATM_TAG, "GrantPermissionAbnormalTest002"); + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.GRANT_SENSITIVE_PERMISSIONS"); + MockHapToken mock("GrantPermissionAbnormalTest002", reqPerm); - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; ASSERT_NE(INVALID_TOKENID, tokenID); + int32_t invalidFlag = -1; int32_t ret = AccessTokenKit::GrantPermission(tokenID, "ohos.permission.MICROPHONE", invalidFlag); ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -200,8 +208,12 @@ HWTEST_F(GrantPermissionTest, GrantPermissionAbnormalTest002, TestSize.Level0) HWTEST_F(GrantPermissionTest, GrantPermissionSpecsTest001, TestSize.Level0) { LOGI(ATM_DOMAIN, ATM_TAG, "GrantPermissionSpecsTest001"); + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.GRANT_SENSITIVE_PERMISSIONS"); + MockHapToken mock("GrantPermissionSpecsTest001", reqPerm); - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; ASSERT_NE(INVALID_TOKENID, tokenID); uint32_t flag; for (int i = 0; i < CYCLE_TIMES; i++) { @@ -215,7 +227,7 @@ HWTEST_F(GrantPermissionTest, GrantPermissionSpecsTest001, TestSize.Level0) ASSERT_EQ(PERMISSION_USER_FIXED, flag); ASSERT_EQ(RET_SUCCESS, ret); } - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -227,18 +239,17 @@ HWTEST_F(GrantPermissionTest, GrantPermissionSpecsTest001, TestSize.Level0) HWTEST_F(GrantPermissionTest, GrantPermissionSpecsTest002, TestSize.Level0) { LOGI(ATM_DOMAIN, ATM_TAG, "GrantPermissionSpecsTest002"); + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.GRANT_SENSITIVE_PERMISSIONS"); + MockHapToken mock("GrantPermissionSpecsTest002", reqPerm, false); - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestNormalInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); - - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; ASSERT_NE(INVALID_TOKENID, tokenID); int ret = AccessTokenKit::GrantPermission(tokenID, "ohos.permission.MICROPHONE", PERMISSION_USER_FIXED); ASSERT_EQ(ERR_NOT_SYSTEM_APP, ret); - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -250,21 +261,19 @@ HWTEST_F(GrantPermissionTest, GrantPermissionSpecsTest002, TestSize.Level0) HWTEST_F(GrantPermissionTest, GrantPermissionSpecsTest003, TestSize.Level0) { LOGI(ATM_DOMAIN, ATM_TAG, "GrantPermissionSpecsTest003"); + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.GRANT_SENSITIVE_PERMISSIONS"); + MockHapToken mock("GrantPermissionSpecsTest003", reqPerm, true); - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestSystemInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); - - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; int ret = AccessTokenKit::GrantPermission(tokenID, "ohos.permission.MICROPHONE", PERMISSION_USER_FIXED); ASSERT_EQ(RET_SUCCESS, ret); ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.MICROPHONE", false); ASSERT_EQ(PERMISSION_GRANTED, ret); - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } } // namespace AccessToken } // namespace Security diff --git a/interfaces/innerkits/accesstoken/test/unittest/PermissionsTest/revoke_permission_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/PermissionsTest/revoke_permission_test.cpp index edbf36f60e5a053f800c35bf4a1b0e82c0f0790f..de702225e79e36b2033ae7008753dccbeb8c17c0 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/PermissionsTest/revoke_permission_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/PermissionsTest/revoke_permission_test.cpp @@ -33,57 +33,34 @@ namespace OHOS { namespace Security { namespace AccessToken { namespace { -static AccessTokenID g_selfTokenId = 0; +static uint64_t g_selfTokenId = 0; static const std::string TEST_BUNDLE_NAME = "ohos"; static const int INVALID_PERMNAME_LEN = 260; static const unsigned int TEST_TOKENID_INVALID = 0; static const int CYCLE_TIMES = 100; static const int TEST_USER_ID = 0; static constexpr int32_t DEFAULT_API_VERSION = 8; -HapPolicyParams g_infoManagerTestPolicyPrams = TestCommon::GetInfoManagerTestPolicyPrams(); -HapInfoParams g_infoManagerTestSystemInfoParms = TestCommon::GetInfoManagerTestSystemInfoParms(); -HapInfoParams g_infoManagerTestNormalInfoParms = TestCommon::GetInfoManagerTestNormalInfoParms(); }; void RevokePermissionTest::SetUpTestCase() { g_selfTokenId = GetSelfTokenID(); + TestCommon::SetTestEvironment(g_selfTokenId); // clean up test cases - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestNormalInfoParms.userID, - g_infoManagerTestNormalInfoParms.bundleName, - g_infoManagerTestNormalInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestSystemInfoParms.userID, - g_infoManagerTestSystemInfoParms.bundleName, - g_infoManagerTestSystemInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestSystemInfoParms, - TestCommon::GetTestPolicyParams()); - SetSelfTokenID(tokenIdEx.tokenIDEx); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + TestCommon::DeleteTestHapToken(tokenID); } void RevokePermissionTest::TearDownTestCase() { - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestNormalInfoParms.userID, - g_infoManagerTestNormalInfoParms.bundleName, - g_infoManagerTestNormalInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestSystemInfoParms.userID, - g_infoManagerTestSystemInfoParms.bundleName, - g_infoManagerTestSystemInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + TestCommon::DeleteTestHapToken(tokenID); SetSelfTokenID(g_selfTokenId); + TestCommon::ResetTestEvironment(); } void RevokePermissionTest::SetUp() @@ -95,22 +72,42 @@ void RevokePermissionTest::SetUp() .userID = TEST_USER_ID, .bundleName = TEST_BUNDLE_NAME, .instIndex = 0, - .appIDDesc = "appIDDesc", + .appIDDesc = "RevokePermissionTest", .apiVersion = DEFAULT_API_VERSION }; + PermissionStateFull permStatMicro = { + .permissionName = "ohos.permission.MICROPHONE", + .isGeneral = true, + .resDeviceID = {"device3"}, + .grantStatus = {PermissionState::PERMISSION_DENIED}, + .grantFlags = {PermissionFlag::PERMISSION_USER_SET} + }; + PermissionStateFull permStatCamera = { + .permissionName = "ohos.permission.CAMERA", + .isGeneral = true, + .resDeviceID = {"device3"}, + .grantStatus = {PermissionState::PERMISSION_GRANTED}, + .grantFlags = {PermissionFlag::PERMISSION_USER_FIXED} + }; + HapPolicyParams policy = { .apl = APL_NORMAL, - .domain = "domain" + .domain = "RevokePermissionTest", + .permStateList = { permStatMicro, permStatCamera }, }; - TestCommon::TestPreparePermDefList(policy); - TestCommon::TestPreparePermStateList(policy); - AccessTokenKit::AllocHapToken(info, policy); + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ(RET_SUCCESS, TestCommon::AllocTestHapToken(info, policy, tokenIdEx)); + AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(tokenId, INVALID_TOKENID); } void RevokePermissionTest::TearDown() { + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + TestCommon::DeleteTestHapToken(tokenID); } /** @@ -122,8 +119,12 @@ void RevokePermissionTest::TearDown() HWTEST_F(RevokePermissionTest, RevokePermissionFuncTest001, TestSize.Level0) { LOGI(ATM_DOMAIN, ATM_TAG, "RevokePermissionFuncTest001"); + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.REVOKE_SENSITIVE_PERMISSIONS"); + MockHapToken mock("RevokePermissionFuncTest001", reqPerm); - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; ASSERT_NE(INVALID_TOKENID, tokenID); int ret = AccessTokenKit::RevokePermission(tokenID, "ohos.permission.MICROPHONE", PERMISSION_USER_FIXED); ASSERT_EQ(RET_SUCCESS, ret); @@ -131,14 +132,13 @@ HWTEST_F(RevokePermissionTest, RevokePermissionFuncTest001, TestSize.Level0) ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.MICROPHONE", false); ASSERT_EQ(PERMISSION_DENIED, ret); - ret = AccessTokenKit::RevokePermission(tokenID, "ohos.permission.SET_WIFI_INFO", PERMISSION_USER_FIXED); + ret = AccessTokenKit::RevokePermission(tokenID, "ohos.permission.CAMERA", PERMISSION_USER_FIXED); ASSERT_EQ(RET_SUCCESS, ret); ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.MICROPHONE", false); ASSERT_EQ(PERMISSION_DENIED, ret); - ret = AccessTokenKit::DeleteToken(tokenID); - ASSERT_EQ(RET_SUCCESS, ret); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -150,15 +150,18 @@ HWTEST_F(RevokePermissionTest, RevokePermissionFuncTest001, TestSize.Level0) HWTEST_F(RevokePermissionTest, RevokePermissionAbnormalTest001, TestSize.Level0) { LOGI(ATM_DOMAIN, ATM_TAG, "RevokePermissionAbnormalTest001"); + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.REVOKE_SENSITIVE_PERMISSIONS"); + MockHapToken mock("RevokePermissionAbnormalTest001", reqPerm); - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; ASSERT_NE(INVALID_TOKENID, tokenID); int ret = AccessTokenKit::RevokePermission(tokenID, "ohos.permission.GAMMA", PERMISSION_USER_FIXED); ASSERT_EQ(ERR_PERMISSION_NOT_EXIST, ret); - ret = AccessTokenKit::DeleteToken(tokenID); - ASSERT_EQ(RET_SUCCESS, ret); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -170,8 +173,12 @@ HWTEST_F(RevokePermissionTest, RevokePermissionAbnormalTest001, TestSize.Level0) HWTEST_F(RevokePermissionTest, RevokePermissionAbnormalTest002, TestSize.Level0) { LOGI(ATM_DOMAIN, ATM_TAG, "RevokePermissionAbnormalTest002"); + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.REVOKE_SENSITIVE_PERMISSIONS"); + MockHapToken mock("RevokePermissionAbnormalTest002", reqPerm); - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; ASSERT_NE(INVALID_TOKENID, tokenID); int ret = AccessTokenKit::RevokePermission(tokenID, "", PERMISSION_USER_FIXED); @@ -181,11 +188,10 @@ HWTEST_F(RevokePermissionTest, RevokePermissionAbnormalTest002, TestSize.Level0) ret = AccessTokenKit::RevokePermission(tokenID, invalidPerm, PERMISSION_USER_FIXED); ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); - ret = AccessTokenKit::RevokePermission(TEST_TOKENID_INVALID, "ohos.permission.BETA", PERMISSION_USER_FIXED); + ret = AccessTokenKit::RevokePermission(TEST_TOKENID_INVALID, "ohos.permission.MICROPHONE", PERMISSION_USER_FIXED); ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); - ret = AccessTokenKit::DeleteToken(tokenID); - ASSERT_EQ(RET_SUCCESS, ret); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); ret = AccessTokenKit::RevokePermission(tokenID, "ohos.permission.BETA", PERMISSION_USER_FIXED); ASSERT_EQ(ERR_PERMISSION_NOT_EXIST, ret); @@ -200,14 +206,19 @@ HWTEST_F(RevokePermissionTest, RevokePermissionAbnormalTest002, TestSize.Level0) HWTEST_F(RevokePermissionTest, RevokePermissionAbnormalTest003, TestSize.Level0) { LOGI(ATM_DOMAIN, ATM_TAG, "RevokePermissionAbnormalTest003"); + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.REVOKE_SENSITIVE_PERMISSIONS"); + MockHapToken mock("RevokePermissionAbnormalTest003", reqPerm); - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; ASSERT_NE(INVALID_TOKENID, tokenID); + int invalidFlag = -1; int32_t ret = AccessTokenKit::RevokePermission(tokenID, "ohos.permission.MICROPHONE", invalidFlag); ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -219,8 +230,12 @@ HWTEST_F(RevokePermissionTest, RevokePermissionAbnormalTest003, TestSize.Level0) HWTEST_F(RevokePermissionTest, RevokePermissionSpecsTest001, TestSize.Level0) { LOGI(ATM_DOMAIN, ATM_TAG, "RevokePermissionSpecsTest001"); + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.REVOKE_SENSITIVE_PERMISSIONS"); + MockHapToken mock("RevokePermissionSpecsTest001", reqPerm); - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; ASSERT_NE(INVALID_TOKENID, tokenID); uint32_t flag; for (int i = 0; i < CYCLE_TIMES; i++) { @@ -234,7 +249,7 @@ HWTEST_F(RevokePermissionTest, RevokePermissionSpecsTest001, TestSize.Level0) ASSERT_EQ(PERMISSION_USER_FIXED, flag); ASSERT_EQ(RET_SUCCESS, ret); } - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -246,19 +261,18 @@ HWTEST_F(RevokePermissionTest, RevokePermissionSpecsTest001, TestSize.Level0) HWTEST_F(RevokePermissionTest, RevokePermissionSpecsTest002, TestSize.Level0) { LOGI(ATM_DOMAIN, ATM_TAG, "RevokePermissionSpecsTest002"); + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.REVOKE_SENSITIVE_PERMISSIONS"); + MockHapToken mock("RevokePermissionSpecsTest002", reqPerm, false); - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestNormalInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); - - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; ASSERT_NE(INVALID_TOKENID, tokenID); + int ret = AccessTokenKit::RevokePermission(tokenID, "ohos.permission.MICROPHONE", PERMISSION_USER_FIXED); ASSERT_EQ(ERR_NOT_SYSTEM_APP, ret); - ret = AccessTokenKit::DeleteToken(tokenID); - ASSERT_EQ(RET_SUCCESS, ret); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -270,28 +284,27 @@ HWTEST_F(RevokePermissionTest, RevokePermissionSpecsTest002, TestSize.Level0) HWTEST_F(RevokePermissionTest, RevokePermissionSpecsTest003, TestSize.Level0) { LOGI(ATM_DOMAIN, ATM_TAG, "RevokePermissionSpecsTest003"); + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.REVOKE_SENSITIVE_PERMISSIONS"); + MockHapToken mock("RevokePermissionSpecsTest003", reqPerm, true); - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestSystemInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); - - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; ASSERT_NE(INVALID_TOKENID, tokenID); + int ret = AccessTokenKit::RevokePermission(tokenID, "ohos.permission.MICROPHONE", PERMISSION_USER_FIXED); ASSERT_EQ(RET_SUCCESS, ret); ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.MICROPHONE", false); ASSERT_EQ(PERMISSION_DENIED, ret); - ret = AccessTokenKit::RevokePermission(tokenID, "ohos.permission.SET_WIFI_INFO", PERMISSION_USER_FIXED); + ret = AccessTokenKit::RevokePermission(tokenID, "ohos.permission.CAMERA", PERMISSION_USER_FIXED); ASSERT_EQ(RET_SUCCESS, ret); ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.MICROPHONE", false); ASSERT_EQ(PERMISSION_DENIED, ret); - ret = AccessTokenKit::DeleteToken(tokenID); - ASSERT_EQ(RET_SUCCESS, ret); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } } // namespace AccessToken } // namespace Security diff --git a/interfaces/innerkits/accesstoken/test/unittest/PermissionsTest/verify_access_token_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/PermissionsTest/verify_access_token_test.cpp index b298e430d735d5e4ccbef3d9c0b4a237ea1ed303..262d7ca2df0fbe5e5b80b0d19ef1f71fcb7d2fc9 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/PermissionsTest/verify_access_token_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/PermissionsTest/verify_access_token_test.cpp @@ -33,55 +33,33 @@ namespace OHOS { namespace Security { namespace AccessToken { namespace { -static AccessTokenID g_selfTokenId = 0; +static uint64_t g_selfTokenId = 0; static const std::string TEST_BUNDLE_NAME = "ohos"; static const int INVALID_PERMNAME_LEN = 260; static const unsigned int TEST_TOKENID_INVALID = 0; static const int TEST_USER_ID = 0; static constexpr int32_t DEFAULT_API_VERSION = 8; -HapInfoParams g_infoManagerTestSystemInfoParms = TestCommon::GetInfoManagerTestSystemInfoParms(); -HapInfoParams g_infoManagerTestNormalInfoParms = TestCommon::GetInfoManagerTestNormalInfoParms(); }; void VerifyAccessTokenTest::SetUpTestCase() { g_selfTokenId = GetSelfTokenID(); + TestCommon::SetTestEvironment(g_selfTokenId); // clean up test cases - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestNormalInfoParms.userID, - g_infoManagerTestNormalInfoParms.bundleName, - g_infoManagerTestNormalInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestSystemInfoParms.userID, - g_infoManagerTestSystemInfoParms.bundleName, - g_infoManagerTestSystemInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestSystemInfoParms, - TestCommon::GetTestPolicyParams()); - SetSelfTokenID(tokenIdEx.tokenIDEx); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + TestCommon::DeleteTestHapToken(tokenID); } void VerifyAccessTokenTest::TearDownTestCase() { - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestNormalInfoParms.userID, - g_infoManagerTestNormalInfoParms.bundleName, - g_infoManagerTestNormalInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestSystemInfoParms.userID, - g_infoManagerTestSystemInfoParms.bundleName, - g_infoManagerTestSystemInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + TestCommon::DeleteTestHapToken(tokenID); SetSelfTokenID(g_selfTokenId); + TestCommon::ResetTestEvironment(); } void VerifyAccessTokenTest::SetUp() @@ -93,22 +71,40 @@ void VerifyAccessTokenTest::SetUp() .userID = TEST_USER_ID, .bundleName = TEST_BUNDLE_NAME, .instIndex = 0, - .appIDDesc = "appIDDesc", + .appIDDesc = "VerifyAccessTokenTest", .apiVersion = DEFAULT_API_VERSION }; + PermissionStateFull permStatMicro = { + .permissionName = "ohos.permission.MICROPHONE", + .isGeneral = true, + .resDeviceID = {"device3"}, + .grantStatus = {PermissionState::PERMISSION_DENIED}, + .grantFlags = {PermissionFlag::PERMISSION_USER_SET} + }; + PermissionStateFull permStatLocation = { + .permissionName = "ohos.permission.APPROXIMATELY_LOCATION", + .isGeneral = true, + .resDeviceID = {"device3"}, + .grantStatus = {PermissionState::PERMISSION_DENIED}, + .grantFlags = {PermissionFlag::PERMISSION_USER_FIXED} + }; + HapPolicyParams policy = { .apl = APL_NORMAL, - .domain = "domain" + .domain = "VerifyAccessTokenTest", + .permStateList = { permStatMicro, permStatLocation }, }; - TestCommon::TestPreparePermDefList(policy); - TestCommon::TestPreparePermStateList(policy); - AccessTokenKit::AllocHapToken(info, policy); + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ(RET_SUCCESS, TestCommon::AllocTestHapToken(info, policy, tokenIdEx)); + ASSERT_NE(tokenIdEx.tokenIdExStruct.tokenID, INVALID_TOKENID); } void VerifyAccessTokenTest::TearDown() { + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID); } /** @@ -120,9 +116,9 @@ void VerifyAccessTokenTest::TearDown() HWTEST_F(VerifyAccessTokenTest, VerifyAccessTokenFuncTest001, TestSize.Level0) { LOGI(ATM_DOMAIN, ATM_TAG, "VerifyAccessTokenFuncTest001"); - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); - int ret = AccessTokenKit::GrantPermission(tokenID, "ohos.permission.MICROPHONE", PERMISSION_USER_FIXED); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + int ret = TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.MICROPHONE", PERMISSION_USER_FIXED); ASSERT_EQ(RET_SUCCESS, ret); ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.MICROPHONE"); @@ -130,7 +126,7 @@ HWTEST_F(VerifyAccessTokenTest, VerifyAccessTokenFuncTest001, TestSize.Level0) ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.MICROPHONE", false); ASSERT_EQ(PERMISSION_GRANTED, ret); - ret = AccessTokenKit::RevokePermission(tokenID, "ohos.permission.MICROPHONE", PERMISSION_USER_FIXED); + ret = TestCommon::RevokePermissionByTest(tokenID, "ohos.permission.MICROPHONE", PERMISSION_USER_FIXED); ASSERT_EQ(RET_SUCCESS, ret); ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.MICROPHONE"); @@ -148,22 +144,23 @@ HWTEST_F(VerifyAccessTokenTest, VerifyAccessTokenFuncTest001, TestSize.Level0) HWTEST_F(VerifyAccessTokenTest, VerifyAccessTokenFuncTest002, TestSize.Level0) { LOGI(ATM_DOMAIN, ATM_TAG, "VerifyAccessTokenFuncTest002"); - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); - int ret = AccessTokenKit::GrantPermission(tokenID, "ohos.permission.SET_WIFI_INFO", PERMISSION_USER_FIXED); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + int ret = + TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_USER_FIXED); ASSERT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.SET_WIFI_INFO"); + ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"); ASSERT_EQ(PERMISSION_GRANTED, ret); - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.SET_WIFI_INFO", false); + ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION", false); ASSERT_EQ(PERMISSION_GRANTED, ret); - ret = AccessTokenKit::RevokePermission(tokenID, "ohos.permission.SET_WIFI_INFO", PERMISSION_USER_FIXED); + ret = TestCommon::RevokePermissionByTest(tokenID, "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_USER_FIXED); ASSERT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.SET_WIFI_INFO"); + ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"); ASSERT_EQ(PERMISSION_DENIED, ret); - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.SET_WIFI_INFO", false); + ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION", false); ASSERT_EQ(PERMISSION_DENIED, ret); } @@ -176,8 +173,8 @@ HWTEST_F(VerifyAccessTokenTest, VerifyAccessTokenFuncTest002, TestSize.Level0) HWTEST_F(VerifyAccessTokenTest, VerifyAccessTokenAbnormalTest001, TestSize.Level0) { LOGI(ATM_DOMAIN, ATM_TAG, "VerifyAccessTokenAbnormalTest001"); - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; int ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.GAMMA", false); ASSERT_EQ(PERMISSION_DENIED, ret); @@ -190,16 +187,16 @@ HWTEST_F(VerifyAccessTokenTest, VerifyAccessTokenAbnormalTest001, TestSize.Level ret = AccessTokenKit::VerifyAccessToken(tokenID, invalidPerm, false); ASSERT_EQ(PERMISSION_DENIED, ret); - AccessTokenKit::VerifyAccessToken(TEST_TOKENID_INVALID, "ohos.permission.SET_WIFI_INFO"); + AccessTokenKit::VerifyAccessToken(TEST_TOKENID_INVALID, "ohos.permission.APPROXIMATELY_LOCATION"); ASSERT_EQ(PERMISSION_DENIED, ret); - AccessTokenKit::VerifyAccessToken(TEST_TOKENID_INVALID, "ohos.permission.SET_WIFI_INFO", false); + AccessTokenKit::VerifyAccessToken(TEST_TOKENID_INVALID, "ohos.permission.APPROXIMATELY_LOCATION", false); ASSERT_EQ(PERMISSION_DENIED, ret); AccessTokenKit::DeleteToken(tokenID); - AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.SET_WIFI_INFO"); + AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION"); ASSERT_EQ(PERMISSION_DENIED, ret); - AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.SET_WIFI_INFO", false); + AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.APPROXIMATELY_LOCATION", false); ASSERT_EQ(PERMISSION_DENIED, ret); } @@ -212,16 +209,16 @@ HWTEST_F(VerifyAccessTokenTest, VerifyAccessTokenAbnormalTest001, TestSize.Level HWTEST_F(VerifyAccessTokenTest, VerifyAccessTokenWithListFuncTest001, TestSize.Level0) { LOGI(ATM_DOMAIN, ATM_TAG, "VerifyAccessTokenWithListFuncTest001"); - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); - int ret = AccessTokenKit::GrantPermission(tokenID, "ohos.permission.MICROPHONE", PERMISSION_USER_FIXED); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + int ret = TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.MICROPHONE", PERMISSION_USER_FIXED); ASSERT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::GrantPermission(tokenID, "ohos.permission.SET_WIFI_INFO", PERMISSION_USER_FIXED); + ret = TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_USER_FIXED); ASSERT_EQ(RET_SUCCESS, ret); std::vector permissionList; permissionList.emplace_back("ohos.permission.MICROPHONE"); - permissionList.emplace_back("ohos.permission.SET_WIFI_INFO"); + permissionList.emplace_back("ohos.permission.APPROXIMATELY_LOCATION"); std::vector permStateList; ret = AccessTokenKit::VerifyAccessToken(tokenID, permissionList, permStateList); @@ -235,9 +232,9 @@ HWTEST_F(VerifyAccessTokenTest, VerifyAccessTokenWithListFuncTest001, TestSize.L ASSERT_EQ(PERMISSION_GRANTED, permStateList[i]); } - ret = AccessTokenKit::RevokePermission(tokenID, "ohos.permission.MICROPHONE", PERMISSION_USER_FIXED); + ret = TestCommon::RevokePermissionByTest(tokenID, "ohos.permission.MICROPHONE", PERMISSION_USER_FIXED); ASSERT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::RevokePermission(tokenID, "ohos.permission.SET_WIFI_INFO", PERMISSION_USER_FIXED); + ret = TestCommon::RevokePermissionByTest(tokenID, "ohos.permission.APPROXIMATELY_LOCATION", PERMISSION_USER_FIXED); ASSERT_EQ(RET_SUCCESS, ret); permStateList.clear(); @@ -262,8 +259,8 @@ HWTEST_F(VerifyAccessTokenTest, VerifyAccessTokenWithListFuncTest001, TestSize.L HWTEST_F(VerifyAccessTokenTest, VerifyAccessTokenWithListAbnormalTest001, TestSize.Level0) { LOGI(ATM_DOMAIN, ATM_TAG, "VerifyAccessTokenWithListAbnormalTest001"); - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; std::vector permissionList; permissionList.emplace_back("ohos.permission.GAMMA"); @@ -289,7 +286,7 @@ HWTEST_F(VerifyAccessTokenTest, VerifyAccessTokenWithListAbnormalTest001, TestSi permissionList.clear(); permissionList.emplace_back("ohos.permission.MICROPHONE"); - permissionList.emplace_back("ohos.permission.SET_WIFI_INFO"); + permissionList.emplace_back("ohos.permission.APPROXIMATELY_LOCATION"); permissionList.emplace_back(invalidPerm); permStateList.clear(); ret = AccessTokenKit::VerifyAccessToken(TEST_TOKENID_INVALID, permissionList, permStateList); diff --git a/interfaces/innerkits/accesstoken/test/unittest/ProxyMockTest/accesstoken_mock_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/ProxyMockTest/accesstoken_mock_test.cpp index 710d394e26e6e0db01fca58fd314fe8fb7f42a11..1678ab82f99baf1ac8b96b27072b24a32e1bb2d9 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/ProxyMockTest/accesstoken_mock_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/ProxyMockTest/accesstoken_mock_test.cpp @@ -611,6 +611,19 @@ HWTEST_F(AccessTokenMockTest, RequestAppPermOnSettingTest001, TestSize.Level1) AccessTokenID tokenId = 123; ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::RequestAppPermOnSetting(tokenId)); } + +/** + * @tc.name: GetKernelPermissions001 + * @tc.desc: GetKernelPermissions with proxy is null + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(AccessTokenMockTest, GetKernelPermissions001, TestSize.Level1) +{ + AccessTokenID tokenId = 123; + std::vector kernelPermList; + ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::GetKernelPermissions(tokenId, kernelPermList)); +} } // namespace AccessToken } // namespace Security } diff --git a/interfaces/innerkits/accesstoken/test/unittest/RegisterCallbackTest/register_perm_state_change_callback_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/RegisterCallbackTest/register_perm_state_change_callback_test.cpp index 9d19b349de273aabbd256ec8da5bc855b6917f89..0e1383786f4d58ab9fcd9e9eb4e2b1e19add6061 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/RegisterCallbackTest/register_perm_state_change_callback_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/RegisterCallbackTest/register_perm_state_change_callback_test.cpp @@ -36,123 +36,47 @@ namespace OHOS { namespace Security { namespace AccessToken { namespace { -static const std::string TEST_BUNDLE_NAME = "ohos"; -static const int TEST_USER_ID = 0; - -HapInfoParams g_locationTestInfo = { - .userID = TEST_USER_ID, - .bundleName = "accesstoken_location_test", - .instIndex = 0, - .appIDDesc = "test2" -}; - -HapInfoParams g_infoManagerTestNormalInfoParms = TestCommon::GetInfoManagerTestNormalInfoParms(); -HapInfoParams g_infoManagerTestSystemInfoParms = TestCommon::GetInfoManagerTestSystemInfoParms(); +static MockHapToken* g_mock = nullptr; HapInfoParams g_infoManagerTestInfoParms = TestCommon::GetInfoManagerTestInfoParms(); -HapPolicyParams g_infoManagerTestPolicyPrams = TestCommon::GetInfoManagerTestPolicyPrams(); - -HapInfoParams g_infoManagerTestInfoParmsBak = g_infoManagerTestInfoParms; -HapPolicyParams g_infoManagerTestPolicyPramsBak = g_infoManagerTestPolicyPrams; - uint64_t g_selfShellTokenId; +static const uint32_t TOKENIDS_LIST_SIZE_MAX_TEST = 1024; +static const uint32_t PERMS_LIST_SIZE_MAX_TEST = 1024; +static const uint32_t MAX_CALLBACK_MAP_SIZE = 200; +PermissionStateFull g_infoManagerTestStateA = { + .permissionName = "ohos.permission.CAMERA", + .isGeneral = true, + .resDeviceID = {"local2"}, + .grantStatus = {PERMISSION_DENIED}, + .grantFlags = {1} +}; } void RegisterPermStateChangeCallbackTest::SetUpTestCase() { g_selfShellTokenId = GetSelfTokenID(); - // clean up test cases - AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenId); - - tokenId = AccessTokenKit::GetHapTokenID(g_infoManagerTestNormalInfoParms.userID, - g_infoManagerTestNormalInfoParms.bundleName, - g_infoManagerTestNormalInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenId); - - tokenId = AccessTokenKit::GetHapTokenID(g_infoManagerTestSystemInfoParms.userID, - g_infoManagerTestSystemInfoParms.bundleName, - g_infoManagerTestSystemInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenId); - - tokenId = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenId); - - TestCommon::GetNativeTokenTest(); + TestCommon::SetTestEvironment(g_selfShellTokenId); + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.GET_SENSITIVE_PERMISSIONS"); + g_mock = new (std::nothrow) MockHapToken("RegisterPermStateChangeCallbackTest", reqPerm, true); } void RegisterPermStateChangeCallbackTest::TearDownTestCase() { - SetSelfTokenID(g_selfShellTokenId); + if (g_mock != nullptr) { + delete g_mock; + g_mock = nullptr; + } + EXPECT_EQ(0, SetSelfTokenID(g_selfShellTokenId)); + TestCommon::ResetTestEvironment(); } void RegisterPermStateChangeCallbackTest::SetUp() { - setuid(0); - selfTokenId_ = GetSelfTokenID(); - g_infoManagerTestInfoParms = g_infoManagerTestInfoParmsBak; - g_infoManagerTestPolicyPrams = g_infoManagerTestPolicyPramsBak; - HapInfoParams info = { - .userID = TEST_USER_ID, - .bundleName = TEST_BUNDLE_NAME, - .instIndex = 0, - .appIDDesc = "appIDDesc", - .apiVersion = 8, - .isSystemApp = true - }; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "domain" - }; - AccessTokenKit::AllocHapToken(info, policy); - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); LOGI(ATM_DOMAIN, ATM_TAG, "SetUp ok."); } void RegisterPermStateChangeCallbackTest::TearDown() { - AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenId); - tokenId = AccessTokenKit::GetHapTokenID(g_infoManagerTestNormalInfoParms.userID, - g_infoManagerTestNormalInfoParms.bundleName, - g_infoManagerTestNormalInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenId); - - tokenId = AccessTokenKit::GetHapTokenID(g_infoManagerTestSystemInfoParms.userID, - g_infoManagerTestSystemInfoParms.bundleName, - g_infoManagerTestSystemInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenId); - EXPECT_EQ(0, SetSelfTokenID(selfTokenId_)); -} - -void RegisterPermStateChangeCallbackTest::AllocHapToken(std::vector& permissionDefs, - std::vector& permissionStateFulls, int32_t apiVersion) -{ - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, "accesstoken_location_test", 0); - AccessTokenKit::DeleteToken(tokenID); - - HapInfoParams info = g_locationTestInfo; - info.apiVersion = apiVersion; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "domain" - }; - - for (auto& permissionDef:permissionDefs) { - policy.permList.emplace_back(permissionDef); - } - - for (auto& permissionStateFull:permissionStateFulls) { - policy.permStateList.emplace_back(permissionStateFull); - } - - AccessTokenKit::AllocHapToken(info, policy); } class CbCustomizeTest : public PermStateChangeCallbackCustomize { @@ -190,60 +114,47 @@ HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterPermStateChangeCallbackFun auto callbackPtr = std::make_shared(scopeInfo); callbackPtr->ready_ = false; - int32_t res = AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr); - ASSERT_EQ(RET_SUCCESS, res); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr)); - static PermissionStateFull infoManagerTestStateA = { - .permissionName = "ohos.permission.CAMERA", - .isGeneral = true, - .resDeviceID = {"local2"}, - .grantStatus = {PERMISSION_DENIED}, - .grantFlags = {1} - }; static HapPolicyParams infoManagerTestPolicyPrams1 = { .apl = APL_NORMAL, .domain = "test.domain2", - .permList = {}, - .permStateList = {infoManagerTestStateA} + .permStateList = {g_infoManagerTestStateA} }; - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1); + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ( + RET_SUCCESS, TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1, tokenIdEx)); AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; - ASSERT_NE(INVALID_TOKENID, tokenID); + ASSERT_NE(tokenID, INVALID_TOKENID); - res = AccessTokenKit::GrantPermission(tokenID, "ohos.permission.CAMERA", 2); - ASSERT_EQ(RET_SUCCESS, res); + ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.CAMERA", 2)); - res = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.CAMERA", false); - ASSERT_EQ(PERMISSION_GRANTED, res); + ASSERT_EQ(PERMISSION_GRANTED, AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.CAMERA", false)); usleep(500000); // 500000us = 0.5s EXPECT_EQ(true, callbackPtr->ready_); callbackPtr->ready_ = false; - res = AccessTokenKit::RevokePermission(tokenID, "ohos.permission.CAMERA", 2); - ASSERT_EQ(RET_SUCCESS, res); + ASSERT_EQ(RET_SUCCESS, TestCommon::RevokePermissionByTest(tokenID, "ohos.permission.CAMERA", 2)); usleep(500000); // 500000us = 0.5s EXPECT_EQ(true, callbackPtr->ready_); - res = AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr); - ASSERT_EQ(RET_SUCCESS, res); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr)); callbackPtr->ready_ = false; - res = AccessTokenKit::GrantPermission(tokenID, "ohos.permission.CAMERA", 2); - ASSERT_EQ(RET_SUCCESS, res); + ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.CAMERA", 2)); usleep(500000); // 500000us = 0.5s ASSERT_EQ(false, callbackPtr->ready_); callbackPtr->ready_ = false; - res = AccessTokenKit::RevokePermission(tokenID, "ohos.permission.CAMERA", 2); - ASSERT_EQ(RET_SUCCESS, res); + ASSERT_EQ(RET_SUCCESS, TestCommon::RevokePermissionByTest(tokenID, "ohos.permission.CAMERA", 2)); usleep(500000); // 500000us = 0.5s ASSERT_EQ(false, callbackPtr->ready_); - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -256,7 +167,7 @@ HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterPermStateChangeCallbackFun { LOGI(ATM_DOMAIN, ATM_TAG, "RegisterPermStateChangeCallbackFuncTest002"); PermStateChangeScope scopeInfo; - scopeInfo.permList = {"ohos.permission.GET_BUNDLE_INFO"}; + scopeInfo.permList = {"ohos.permission.APPROXIMATELY_LOCATION"}; scopeInfo.tokenIDs = {}; auto callbackPtr = std::make_shared(scopeInfo); callbackPtr->ready_ = false; @@ -264,7 +175,7 @@ HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterPermStateChangeCallbackFun int32_t res = AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr); static PermissionStateFull infoManagerTestStateA = { - .permissionName = "ohos.permission.GET_BUNDLE_INFO", + .permissionName = "ohos.permission.APPROXIMATELY_LOCATION", .isGeneral = true, .resDeviceID = {"local2"}, .grantStatus = {PERMISSION_GRANTED}, @@ -280,25 +191,24 @@ HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterPermStateChangeCallbackFun static HapPolicyParams infoManagerTestPolicyPrams2 = { .apl = APL_SYSTEM_BASIC, .domain = "test.domain2", - .permList = {}, .permStateList = {infoManagerTestStateA, infoManagerTestStateB} }; AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams2); - + ASSERT_EQ( + RET_SUCCESS, TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams2, tokenIdEx)); AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(tokenID, INVALID_TOKENID); res = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.CAMERA", false); - ASSERT_EQ(PERMISSION_GRANTED, res); + ASSERT_EQ(PERMISSION_DENIED, res); - res = AccessTokenKit::GrantPermission(tokenID, "ohos.permission.CAMERA", 2); + res = TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.CAMERA", 2); ASSERT_EQ(RET_SUCCESS, res); usleep(500000); // 500000us = 0.5s EXPECT_EQ(false, callbackPtr->ready_); - res = AccessTokenKit::DeleteToken(tokenID); - ASSERT_EQ(RET_SUCCESS, res); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); res = AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr); ASSERT_EQ(RET_SUCCESS, res); @@ -319,55 +229,29 @@ HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterPermStateChangeCallbackFun auto callbackPtr = std::make_shared(scopeInfo); callbackPtr->ready_ = false; - int32_t res = AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr)); - static PermissionStateFull infoManagerTestStateA = { - .permissionName = "ohos.permission.GET_BUNDLE_INFO", - .isGeneral = true, - .resDeviceID = {"local2"}, - .grantStatus = {PERMISSION_DENIED}, - .grantFlags = {1} - }; - static PermissionStateFull infoManagerTestStateB = { - .permissionName = "ohos.permission.CAMERA", - .isGeneral = true, - .resDeviceID = {"local2"}, - .grantStatus = {PERMISSION_DENIED}, - .grantFlags = {1} - }; - static HapPolicyParams infoManagerTestPolicyPrams3 = { + HapPolicyParams infoManagerTestPolicyPrams3 = { .apl = APL_SYSTEM_CORE, .domain = "test.domain2", - .permList = {}, - .permStateList = {infoManagerTestStateA, infoManagerTestStateB} + .permStateList = {g_infoManagerTestStateA} }; AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams3); - + ASSERT_EQ( + RET_SUCCESS, TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams3, tokenIdEx)); AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(tokenID, INVALID_TOKENID); callbackPtr->ready_ = false; - res = AccessTokenKit::GrantPermission(tokenID, "ohos.permission.CAMERA", 2); - ASSERT_EQ(RET_SUCCESS, res); - res = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.CAMERA", false); - ASSERT_EQ(PERMISSION_GRANTED, res); - usleep(500000); // 500000us = 0.5s - EXPECT_EQ(true, callbackPtr->ready_); - - callbackPtr->ready_ = false; - res = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.GET_BUNDLE_INFO", false); - ASSERT_EQ(PERMISSION_DENIED, res); - res = AccessTokenKit::GrantPermission(tokenID, "ohos.permission.GET_BUNDLE_INFO", 2); - ASSERT_EQ(RET_SUCCESS, res); + ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.CAMERA", 2)); + ASSERT_EQ(PERMISSION_GRANTED, AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.CAMERA", false)); usleep(500000); // 500000us = 0.5s EXPECT_EQ(true, callbackPtr->ready_); - res = AccessTokenKit::DeleteToken(tokenID); - ASSERT_EQ(RET_SUCCESS, res); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); - res = AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr); - ASSERT_EQ(RET_SUCCESS, res); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr)); } /** @@ -379,61 +263,36 @@ HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterPermStateChangeCallbackFun HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterPermStateChangeCallbackFuncTest004, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "RegisterPermStateChangeCallbackFuncTest004"); - static PermissionStateFull infoManagerTestStateA = { - .permissionName = "ohos.permission.CAMERA", - .isGeneral = true, - .resDeviceID = {"local2"}, - .grantStatus = {PERMISSION_DENIED}, - .grantFlags = {1} - }; - static PermissionStateFull infoManagerTestStateB = { - .permissionName = "ohos.permission.GET_BUNDLE_INFO", - .isGeneral = true, - .resDeviceID = {"local2"}, - .grantStatus = {PERMISSION_GRANTED}, - .grantFlags = {1} - }; + static HapPolicyParams infoManagerTestPolicyPrams5 = { .apl = APL_NORMAL, .domain = "test.domain2", - .permList = {}, - .permStateList = {infoManagerTestStateA, infoManagerTestStateB} + .permStateList = {g_infoManagerTestStateA} }; AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams5); - + ASSERT_EQ( + RET_SUCCESS, TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams5, tokenIdEx)); AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(tokenID, INVALID_TOKENID); PermStateChangeScope scopeInfo; - scopeInfo.permList = {"ohos.permission.GET_BUNDLE_INFO", "ohos.permission.CAMERA"}; + scopeInfo.permList = {"ohos.permission.CAMERA"}; scopeInfo.tokenIDs = {tokenID, 0}; auto callbackPtr = std::make_shared(scopeInfo); callbackPtr->ready_ = false; - int32_t res = AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr)); callbackPtr->ready_ = false; - res = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.CAMERA", false); - ASSERT_EQ(PERMISSION_DENIED, res); - res = AccessTokenKit::GrantPermission(tokenID, "ohos.permission.CAMERA", 2); + ASSERT_EQ(PERMISSION_DENIED, AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.CAMERA", false)); + ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.CAMERA", 2)); usleep(500000); // 500000us = 0.5s - ASSERT_EQ(RET_SUCCESS, res); EXPECT_EQ(true, callbackPtr->ready_); - callbackPtr->ready_ = false; - res = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.GET_BUNDLE_INFO", false); - ASSERT_EQ(PERMISSION_GRANTED, res); - res = AccessTokenKit::GrantPermission(tokenID, "ohos.permission.GET_BUNDLE_INFO", 2); - ASSERT_EQ(RET_SUCCESS, res); - usleep(500000); // 500000us = 0.5s - EXPECT_EQ(false, callbackPtr->ready_); - - res = AccessTokenKit::DeleteToken(tokenID); - ASSERT_EQ(RET_SUCCESS, res); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); - res = AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr); - ASSERT_EQ(RET_SUCCESS, res); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr)); } @@ -446,10 +305,9 @@ HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterPermStateChangeCallbackFun HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterPermStateChangeCallbackFuncTest005, TestSize.Level0) { LOGI(ATM_DOMAIN, ATM_TAG, "RegisterPermStateChangeCallbackFuncTest005"); - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestNormalInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.GET_SENSITIVE_PERMISSIONS"); + MockHapToken mock("RegisterPermStateChangeCallbackFuncTest005", reqPerm, false); PermStateChangeScope scopeInfo; scopeInfo.permList = {"ohos.permission.CAMERA"}; @@ -457,8 +315,7 @@ HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterPermStateChangeCallbackFun auto callbackPtr = std::make_shared(scopeInfo); callbackPtr->ready_ = false; - int32_t res = AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr); - ASSERT_EQ(ERR_NOT_SYSTEM_APP, res); + ASSERT_EQ(ERR_NOT_SYSTEM_APP, AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr)); } /** @@ -470,22 +327,9 @@ HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterPermStateChangeCallbackFun HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterPermStateChangeCallbackFuncTest006, TestSize.Level0) { LOGI(ATM_DOMAIN, ATM_TAG, "RegisterPermStateChangeCallbackFuncTest006"); - static HapPolicyParams policyPrams = { - .apl = APL_SYSTEM_CORE, - .domain = "test.domain", - }; - PermissionStateFull g_getPermissionReq = { - .permissionName = "ohos.permission.GET_SENSITIVE_PERMISSIONS", - .isGeneral = true, - .resDeviceID = {"device2"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED} - }; - policyPrams.permStateList.emplace_back(g_getPermissionReq); - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestSystemInfoParms, policyPrams); - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.GET_SENSITIVE_PERMISSIONS"); + MockHapToken mock("RegisterPermStateChangeCallbackFuncTest006", reqPerm, true); PermStateChangeScope scopeInfo; scopeInfo.permList = {"ohos.permission.CAMERA"}; @@ -493,13 +337,10 @@ HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterPermStateChangeCallbackFun auto callbackPtr = std::make_shared(scopeInfo); callbackPtr->ready_ = false; - int32_t res = AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr); - ASSERT_EQ(RET_SUCCESS, res); - res = AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr); - ASSERT_EQ(RET_SUCCESS, res); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr)); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr)); } - /** * @tc.name: RegisterPermStateChangeCallbackAbnormalTest001 * @tc.desc: RegisterPermStateChangeCallback with invalid tokenId @@ -510,59 +351,40 @@ HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterPermStateChangeCallbackAbn { LOGI(ATM_DOMAIN, ATM_TAG, "RegisterPermStateChangeCallbackAbnormalTest001"); PermStateChangeScope scopeInfo; - scopeInfo.permList = {"ohos.permission.GET_BUNDLE_INFO", "ohos.permission.CAMERA"}; + scopeInfo.permList = {"ohos.permission.CAMERA"}; scopeInfo.tokenIDs = {555555}; // 555555为模拟的tokenid auto callbackPtr = std::make_shared(scopeInfo); callbackPtr->ready_ = false; - int32_t res = AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, res); + ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr)); - static PermissionStateFull infoManagerTestStateA = { - .permissionName = "ohos.permission.GET_BUNDLE_INFO", - .isGeneral = true, - .resDeviceID = {"local2"}, - .grantStatus = {PERMISSION_GRANTED}, - .grantFlags = {1}, - }; - static PermissionStateFull infoManagerTestStateB = { + PermissionStateFull infoManagerTestStateA = { .permissionName = "ohos.permission.CAMERA", .isGeneral = true, .resDeviceID = {"local2"}, .grantStatus = {PERMISSION_GRANTED}, .grantFlags = {1} }; - static HapPolicyParams infoManagerTestPolicyPrams4 = { + HapPolicyParams infoManagerTestPolicyPrams4 = { .apl = APL_NORMAL, .domain = "test.domain2", - .permList = {}, - .permStateList = {infoManagerTestStateA, infoManagerTestStateB} + .permStateList = {infoManagerTestStateA} }; AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams4); - + ASSERT_EQ( + RET_SUCCESS, TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams4, tokenIdEx)); AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(tokenID, INVALID_TOKENID); callbackPtr->ready_ = false; - res = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.CAMERA", false); - ASSERT_EQ(PERMISSION_GRANTED, res); - res = AccessTokenKit::RevokePermission(tokenID, "ohos.permission.CAMERA", 2); - ASSERT_EQ(RET_SUCCESS, res); - res = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.CAMERA", false); - ASSERT_EQ(PERMISSION_DENIED, res); - usleep(500000); // 500000us = 0.5s - EXPECT_EQ(false, callbackPtr->ready_); - - callbackPtr->ready_ = false; - res = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.GET_BUNDLE_INFO", false); - ASSERT_EQ(PERMISSION_GRANTED, res); - res = AccessTokenKit::RevokePermission(tokenID, "ohos.permission.GET_BUNDLE_INFO", 2); - ASSERT_EQ(RET_SUCCESS, res); + ASSERT_EQ(PERMISSION_DENIED, AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.CAMERA", false)); + ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.CAMERA", 2)); + ASSERT_EQ(PERMISSION_GRANTED, AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.CAMERA", false)); usleep(500000); // 500000us = 0.5s EXPECT_EQ(false, callbackPtr->ready_); - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); } /** @@ -578,8 +400,7 @@ HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterPermStateChangeCallbackAbn scopeInfo.permList = {"ohos.permission.INVALID"}; scopeInfo.tokenIDs = {}; auto callbackPtr1 = std::make_shared(scopeInfo); - int32_t res = AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr1); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, res); + ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr1)); static PermissionStateFull infoManagerTestState = { .permissionName = "ohos.permission.CAMERA", @@ -591,26 +412,25 @@ HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterPermStateChangeCallbackAbn static HapPolicyParams infoManagerTestPolicyPrams6 = { .apl = APL_SYSTEM_BASIC, .domain = "test.domain2", - .permList = {}, .permStateList = {infoManagerTestState} }; AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams6); + ASSERT_EQ( + RET_SUCCESS, TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams6, tokenIdEx)); + ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIdExStruct.tokenID); scopeInfo.tokenIDs = {tokenIdEx.tokenIdExStruct.tokenID}; scopeInfo.permList = {"ohos.permission.INVALID", "ohos.permission.CAMERA"}; auto callbackPtr = std::make_shared(scopeInfo); - res = AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr); - ASSERT_EQ(RET_SUCCESS, res); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr)); - res = AccessTokenKit::GrantPermission(tokenIdEx.tokenIdExStruct.tokenID, "ohos.permission.CAMERA", 2); + int32_t res = TestCommon::GrantPermissionByTest(tokenIdEx.tokenIdExStruct.tokenID, "ohos.permission.CAMERA", 2); ASSERT_EQ(RET_SUCCESS, res); usleep(500000); // 500000us = 0.5s EXPECT_EQ(true, callbackPtr->ready_); - res = AccessTokenKit::DeleteToken(tokenIdEx.tokenIdExStruct.tokenID); - ASSERT_EQ(RET_SUCCESS, res); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID)); res = AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr); ASSERT_EQ(RET_SUCCESS, res); @@ -631,7 +451,7 @@ HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterPermStateChangeCallbackAbn /** * @tc.name: RegisterPermStateChangeCallbackSpecTest001 - * @tc.desc: RegisterPermStateChangeCallback with permList, whose size is 1024/1025 + * @tc.desc: RegisterPermStateChangeCallback with permList, whose size is PERMS_LIST_SIZE_MAX_TEST * @tc.type: FUNC * @tc.require: issueI5NT1X */ @@ -641,25 +461,23 @@ HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterPermStateChangeCallbackSpe PermStateChangeScope scopeInfo; scopeInfo.permList = {}; scopeInfo.tokenIDs = {}; - for (int32_t i = 1; i <= 1025; i++) { // 1025 is a invalid size - scopeInfo.permList.emplace_back("ohos.permission.GET_BUNDLE_INFO"); - if (i == 1025) { // 1025 is a invalid size + for (int32_t i = 0; i <= PERMS_LIST_SIZE_MAX_TEST; i++) { + scopeInfo.permList.emplace_back("ohos.permission.APPROXIMATELY_LOCATION"); + if (i == PERMS_LIST_SIZE_MAX_TEST) { auto callbackPtr = std::make_shared(scopeInfo); - int32_t res = AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, res); + ASSERT_EQ( + AccessTokenError::ERR_PARAM_INVALID, AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr)); break; } auto callbackPtr = std::make_shared(scopeInfo); - int32_t res = AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr); - ASSERT_EQ(RET_SUCCESS, res); - res = AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr); - ASSERT_EQ(RET_SUCCESS, res); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr)); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr)); } } /** * @tc.name: RegisterPermStateChangeCallbackSpecTest002 - * @tc.desc: RegisterPermStateChangeCallback with tokenList, whose size is 1024/1025 + * @tc.desc: RegisterPermStateChangeCallback with tokenList, whose token size is oversize * @tc.type: FUNC * @tc.require: issueI5NT1X */ @@ -675,30 +493,28 @@ HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterPermStateChangeCallbackSpe static HapPolicyParams infoManagerTestPolicyPrams8 = { .apl = APL_NORMAL, .domain = "test.domain", - .permList = {}, .permStateList = {} }; AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams8); + ASSERT_EQ( + RET_SUCCESS, TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams8, tokenIdEx)); + ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIdExStruct.tokenID); - for (int32_t i = 1; i <= 1025; i++) { // 1025 is a invalid size + for (int32_t i = 0; i <= TOKENIDS_LIST_SIZE_MAX_TEST; i++) { scopeInfo.tokenIDs.emplace_back(tokenIdEx.tokenIdExStruct.tokenID); - if (i == 1025) { // 1025 is a invalid size + if (i == TOKENIDS_LIST_SIZE_MAX_TEST) { auto callbackPtr1 = std::make_shared(scopeInfo); - int32_t res = AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr1); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, res); + ASSERT_EQ( + AccessTokenError::ERR_PARAM_INVALID, AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr1)); break; } auto callbackPtr1 = std::make_shared(scopeInfo); - int32_t res = AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr1); - ASSERT_EQ(RET_SUCCESS, res); - res = AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr1); - ASSERT_EQ(RET_SUCCESS, res); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr1)); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr1)); } - int32_t res = AccessTokenKit::DeleteToken(tokenIdEx.tokenIdExStruct.tokenID); - ASSERT_EQ(RET_SUCCESS, res); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID)); } /** @@ -715,22 +531,20 @@ HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterPermStateChangeCallbackSpe scopeInfo.tokenIDs = {}; std::vector> callbackList; - for (int32_t i = 0; i < 200; i++) { // 200 is the max size - if (i == 200) { // 200 is the max size + for (int32_t i = 0; i < MAX_CALLBACK_MAP_SIZE; i++) { // 200 is the max size + if (i == MAX_CALLBACK_MAP_SIZE) { // 200 is the max size auto callbackPtr = std::make_shared(scopeInfo); - int32_t res = AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr); - ASSERT_EQ(AccessTokenError::ERR_CALLBACKS_EXCEED_LIMITATION, res); + ASSERT_EQ(AccessTokenError::ERR_CALLBACKS_EXCEED_LIMITATION, + AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr)); break; } auto callbackPtr = std::make_shared(scopeInfo); - int32_t res = AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr); - ASSERT_EQ(RET_SUCCESS, res); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr)); callbackList.emplace_back(callbackPtr); } - for (int32_t i = 0; i < 200; i++) { // release 200 callback + for (int32_t i = 0; i < MAX_CALLBACK_MAP_SIZE; i++) { // release 200 callback auto callbackPtr = callbackList[i]; - int32_t res = AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr); - ASSERT_EQ(RET_SUCCESS, res); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr)); } callbackList.clear(); } @@ -745,22 +559,17 @@ HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterPermStateChangeCallbackSpe { LOGI(ATM_DOMAIN, ATM_TAG, "RegisterPermStateChangeCallbackSpecTest004"); PermStateChangeScope scopeInfo; - static PermissionStateFull infoManagerTestStateA = { - .permissionName = "ohos.permission.CAMERA", - .isGeneral = true, - .resDeviceID = {"local2"}, - .grantStatus = {PERMISSION_DENIED}, - .grantFlags = {1} - }; + static HapPolicyParams infoManagerTestPolicyPrams13 = { .apl = APL_SYSTEM_BASIC, .domain = "test.domain2", - .permList = {}, - .permStateList = {infoManagerTestStateA} + .permStateList = {g_infoManagerTestStateA} }; AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams13); + ASSERT_EQ(RET_SUCCESS, + TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams13, tokenIdEx)); + ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIdExStruct.tokenID); scopeInfo.tokenIDs = {tokenIdEx.tokenIdExStruct.tokenID}; scopeInfo.permList = {"ohos.permission.CAMERA"}; @@ -768,31 +577,33 @@ HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterPermStateChangeCallbackSpe int32_t res = AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr); ASSERT_EQ(RET_SUCCESS, res); - res = AccessTokenKit::GrantPermission(tokenIdEx.tokenIdExStruct.tokenID, "ohos.permission.CAMERA", 2); + res = TestCommon::GrantPermissionByTest(tokenIdEx.tokenIdExStruct.tokenID, "ohos.permission.CAMERA", 2); EXPECT_EQ(RET_SUCCESS, res); usleep(500000); // 500000us = 0.5s EXPECT_EQ(true, callbackPtr->ready_); callbackPtr->ready_ = false; - res = AccessTokenKit::ClearUserGrantedPermissionState(tokenIdEx.tokenIdExStruct.tokenID); - EXPECT_EQ(RET_SUCCESS, res); + { + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.REVOKE_SENSITIVE_PERMISSIONS"); + MockHapToken mock("RegisterPermStateChangeCallbackSpecTest004", reqPerm); + EXPECT_EQ(RET_SUCCESS, AccessTokenKit::ClearUserGrantedPermissionState(tokenIdEx.tokenIdExStruct.tokenID)); + } usleep(500000); // 500000us = 0.5s EXPECT_EQ(true, callbackPtr->ready_); callbackPtr->ready_ = false; - res = AccessTokenKit::GrantPermission(tokenIdEx.tokenIdExStruct.tokenID, "ohos.permission.CAMERA", 2); + res = TestCommon::GrantPermissionByTest(tokenIdEx.tokenIdExStruct.tokenID, "ohos.permission.CAMERA", 2); EXPECT_EQ(RET_SUCCESS, res); usleep(500000); // 500000us = 0.5s EXPECT_EQ(true, callbackPtr->ready_); callbackPtr->ready_ = false; - res = AccessTokenKit::DeleteToken(tokenIdEx.tokenIdExStruct.tokenID); - EXPECT_EQ(RET_SUCCESS, res); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID)); usleep(500000); // 500000us = 0.5s EXPECT_EQ(true, callbackPtr->ready_); - res = AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr); - ASSERT_EQ(RET_SUCCESS, res); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr)); } /** @@ -815,12 +626,13 @@ HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterPermStateChangeCallbackSpe static HapPolicyParams infoManagerTestPolicyPrams14 = { .apl = APL_SYSTEM_BASIC, .domain = "testA.domain2", - .permList = {}, .permStateList = {infoManagerTestStateA} }; AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams14); + ASSERT_EQ(RET_SUCCESS, + TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams14, tokenIdEx)); + ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIdExStruct.tokenID); scopeInfo.tokenIDs = {tokenIdEx.tokenIdExStruct.tokenID}; scopeInfo.permList = {"ohos.permission.READ_MEDIA"}; @@ -828,27 +640,500 @@ HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterPermStateChangeCallbackSpe int32_t res = AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr); ASSERT_EQ(RET_SUCCESS, res); - res = AccessTokenKit::GrantPermission(tokenIdEx.tokenIdExStruct.tokenID, + res = TestCommon::GrantPermissionByTest(tokenIdEx.tokenIdExStruct.tokenID, "ohos.permission.READ_MEDIA", PERMISSION_SYSTEM_FIXED); EXPECT_EQ(RET_SUCCESS, res); usleep(500000); // 500000us = 0.5s EXPECT_EQ(true, callbackPtr->ready_); callbackPtr->ready_ = false; - res = AccessTokenKit::ClearUserGrantedPermissionState(tokenIdEx.tokenIdExStruct.tokenID); - EXPECT_EQ(RET_SUCCESS, res); + { + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.REVOKE_SENSITIVE_PERMISSIONS"); + MockHapToken mock("RegisterPermStateChangeCallbackSpecTest004", reqPerm); + EXPECT_EQ(RET_SUCCESS, AccessTokenKit::ClearUserGrantedPermissionState(tokenIdEx.tokenIdExStruct.tokenID)); + } usleep(500000); // 500000us = 0.5s EXPECT_EQ(false, callbackPtr->ready_); callbackPtr->ready_ = false; - res = AccessTokenKit::DeleteToken(tokenIdEx.tokenIdExStruct.tokenID); - EXPECT_EQ(RET_SUCCESS, res); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID)); usleep(500000); // 500000us = 0.5s EXPECT_EQ(true, callbackPtr->ready_); res = AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr); ASSERT_EQ(RET_SUCCESS, res); } + +/** + * @tc.name: RegisterSelfPermStateChangeCallback001 + * @tc.desc: RegisterSelfPermStateChangeCallback permList + * @tc.type: FUNC + * @tc.require: issueI5NT1X + */ +HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterSelfPermStateChangeCallback001, TestSize.Level1) +{ + static HapPolicyParams infoManagerTestPolicyPrams1 = { + .apl = APL_NORMAL, + .domain = "test.domain2", + .permStateList = {g_infoManagerTestStateA} + }; + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ(RET_SUCCESS, + TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1, tokenIdEx)); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + + PermStateChangeScope scopeInfo; + scopeInfo.permList = {"ohos.permission.CAMERA"}; + scopeInfo.tokenIDs = {tokenID}; + auto callbackPtr = std::make_shared(scopeInfo); + callbackPtr->ready_ = false; + + SetSelfTokenID(tokenID); + int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, res); + SetSelfTokenID(g_selfShellTokenId); + + res = TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.CAMERA", 2); + ASSERT_EQ(RET_SUCCESS, res); + + res = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.CAMERA", false); + ASSERT_EQ(PERMISSION_GRANTED, res); + usleep(500000); // 500000us = 0.5s + EXPECT_EQ(true, callbackPtr->ready_); + + callbackPtr->ready_ = false; + + res = TestCommon::RevokePermissionByTest(tokenID, "ohos.permission.CAMERA", 2); + ASSERT_EQ(RET_SUCCESS, res); + usleep(500000); // 500000us = 0.5s + EXPECT_EQ(true, callbackPtr->ready_); + + SetSelfTokenID(tokenID); + res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, res); + SetSelfTokenID(g_selfShellTokenId); + + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); +} + +/** + * @tc.name: RegisterSelfPermStateChangeCallback002 + * @tc.desc: RegisterSelfPermStateChangeCallback permList + * @tc.type: FUNC + * @tc.require: issueI5NT1X + */ +HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterSelfPermStateChangeCallback002, TestSize.Level1) +{ + static HapPolicyParams infoManagerTestPolicyPrams1 = { + .apl = APL_NORMAL, + .domain = "test.domain2", + .permStateList = {g_infoManagerTestStateA} + }; + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ(RET_SUCCESS, + TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1, tokenIdEx)); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + + PermStateChangeScope scopeInfo; + scopeInfo.permList = {"ohos.permission.CAMERA"}; + scopeInfo.tokenIDs = {tokenID}; + auto callbackPtr = std::make_shared(scopeInfo); + callbackPtr->ready_ = false; + + SetSelfTokenID(tokenID); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr)); + SetSelfTokenID(g_selfShellTokenId); + + ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.CAMERA", 2)); + usleep(500000); // 500000us = 0.5s + EXPECT_EQ(true, callbackPtr->ready_); + + callbackPtr->ready_ = false; + + ASSERT_EQ(RET_SUCCESS, TestCommon::RevokePermissionByTest(tokenID, "ohos.permission.CAMERA", 2)); + usleep(500000); // 500000us = 0.5s + EXPECT_EQ(true, callbackPtr->ready_); + + callbackPtr->ready_ = false; + + SetSelfTokenID(tokenID); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr)); + SetSelfTokenID(g_selfShellTokenId); + + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); +} + +/** + * @tc.name: RegisterSelfPermStateChangeCallback003 + * @tc.desc: RegisterSelfPermStateChangeCallback permList + * @tc.type: FUNC + * @tc.require: issueI5NT1X + */ +HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterSelfPermStateChangeCallback003, TestSize.Level1) +{ + static HapPolicyParams infoManagerTestPolicyPrams1 = { + .apl = APL_NORMAL, + .domain = "test.domain2", + .permStateList = {g_infoManagerTestStateA} + }; + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ(RET_SUCCESS, + TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1, tokenIdEx)); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + + PermStateChangeScope scopeInfo; + scopeInfo.permList = {}; + scopeInfo.tokenIDs = {tokenID}; + auto callbackPtr = std::make_shared(scopeInfo); + callbackPtr->ready_ = false; + + SetSelfTokenID(tokenID); + int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, res); + SetSelfTokenID(g_selfShellTokenId); + + res = TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.CAMERA", 2); + ASSERT_EQ(RET_SUCCESS, res); + + res = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.CAMERA", false); + ASSERT_EQ(PERMISSION_GRANTED, res); + usleep(500000); // 500000us = 0.5s + EXPECT_EQ(true, callbackPtr->ready_); + + callbackPtr->ready_ = false; + + res = TestCommon::RevokePermissionByTest(tokenID, "ohos.permission.CAMERA", 2); + ASSERT_EQ(RET_SUCCESS, res); + usleep(500000); // 500000us = 0.5s + EXPECT_EQ(true, callbackPtr->ready_); + + SetSelfTokenID(tokenID); + res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, res); + SetSelfTokenID(g_selfShellTokenId); + + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID)); +} + +/** + * @tc.name: RegisterSelfPermStateChangeCallback004 + * @tc.desc: RegisterSelfPermStateChangeCallback permList + * @tc.type: FUNC + * @tc.require: issueI5NT1X + */ +HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterSelfPermStateChangeCallback004, TestSize.Level1) +{ + PermissionStateFull infoManagerTestStateB = { + .permissionName = "ohos.permission.MICROPHONE", + .isGeneral = true, + .resDeviceID = {"local2"}, + .grantStatus = {PERMISSION_DENIED}, + .grantFlags = {1} + }; + HapPolicyParams infoManagerTestPolicyPrams1 = { + .apl = APL_NORMAL, + .domain = "test.domain2", + .permStateList = {g_infoManagerTestStateA, infoManagerTestStateB} + }; + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ(RET_SUCCESS, + TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1, tokenIdEx)); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + + PermStateChangeScope scopeInfo; + scopeInfo.permList = {"ohos.permission.CAMERA", "ohos.permission.MICROPHONE"}; + scopeInfo.tokenIDs = {tokenID}; + auto callbackPtr = std::make_shared(scopeInfo); + callbackPtr->ready_ = false; + + SetSelfTokenID(tokenID); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr)); + SetSelfTokenID(g_selfShellTokenId); + + ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.CAMERA", 2)); + usleep(500000); // 500000us = 0.5s + EXPECT_EQ(true, callbackPtr->ready_); + + callbackPtr->ready_ = false; + ASSERT_EQ(RET_SUCCESS, TestCommon::RevokePermissionByTest(tokenID, "ohos.permission.CAMERA", 2)); + usleep(500000); // 500000us = 0.5s + EXPECT_EQ(true, callbackPtr->ready_); + + callbackPtr->ready_ = false; + ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.MICROPHONE", 2)); + usleep(500000); // 500000us = 0.5s + EXPECT_EQ(true, callbackPtr->ready_); + + callbackPtr->ready_ = false; + ASSERT_EQ(RET_SUCCESS, TestCommon::RevokePermissionByTest(tokenID, "ohos.permission.MICROPHONE", 2)); + usleep(500000); // 500000us = 0.5s + EXPECT_EQ(true, callbackPtr->ready_); + + SetSelfTokenID(tokenID); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); +} + +/** + * @tc.name: RegisterSelfPermStateChangeCallback005 + * @tc.desc: RegisterSelfPermStateChangeCallback permList + * @tc.type: FUNC + * @tc.require: issueI5NT1X + */ +HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterSelfPermStateChangeCallback005, TestSize.Level1) +{ + static PermissionStateFull infoManagerTestStateA = { + .permissionName = "ohos.permission.CAMERA", + .isGeneral = true, + .resDeviceID = {"local2"}, + .grantStatus = {PERMISSION_DENIED}, + .grantFlags = {1} + }; + static HapPolicyParams infoManagerTestPolicyPrams1 = { + .apl = APL_NORMAL, + .domain = "test.domain2", + .permStateList = {g_infoManagerTestStateA} + }; + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ(RET_SUCCESS, + TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1, tokenIdEx)); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + + PermStateChangeScope scopeInfo; + scopeInfo.permList = {"ohos.permission.INVALID"}; + scopeInfo.tokenIDs = {tokenID}; + auto callbackPtr1 = std::make_shared(scopeInfo); + callbackPtr1->ready_ = false; + + SetSelfTokenID(tokenID); + int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr1); + ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, res); + + scopeInfo.permList = {"ohos.permission.INVALID", "ohos.permission.CAMERA"}; + auto callbackPtr = std::make_shared(scopeInfo); + res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, res); + SetSelfTokenID(g_selfShellTokenId); + + res = TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.CAMERA", 2); + ASSERT_EQ(RET_SUCCESS, res); + + res = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.CAMERA", false); + ASSERT_EQ(PERMISSION_GRANTED, res); + usleep(500000); // 500000us = 0.5s + EXPECT_EQ(true, callbackPtr->ready_); + + callbackPtr->ready_ = false; + + res = TestCommon::RevokePermissionByTest(tokenID, "ohos.permission.CAMERA", 2); + ASSERT_EQ(RET_SUCCESS, res); + usleep(500000); // 500000us = 0.5s + EXPECT_EQ(true, callbackPtr->ready_); + + SetSelfTokenID(tokenID); + res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, res); + + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); +} + +/** + * @tc.name: RegisterSelfPermStateChangeCallback006 + * @tc.desc: RegisterSelfPermStateChangeCallback with permList, whose size is oversize + * @tc.type: FUNC + * @tc.require: issueI5NT1X + */ +HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterSelfPermStateChangeCallback006, TestSize.Level1) +{ + static PermissionStateFull infoManagerTestStateA = { + .permissionName = "ohos.permission.GET_BUNDLE_INFO", + .isGeneral = true, + .resDeviceID = {"local2"}, + .grantStatus = {PERMISSION_DENIED}, + .grantFlags = {1} + }; + static HapPolicyParams infoManagerTestPolicyPrams1 = { + .apl = APL_NORMAL, + .domain = "test.domain2", + .permList = {}, + .permStateList = {infoManagerTestStateA} + }; + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ(RET_SUCCESS, + TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1, tokenIdEx)); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + SetSelfTokenID(tokenID); + + PermStateChangeScope scopeInfo; + scopeInfo.permList = {}; + scopeInfo.tokenIDs = {GetSelfTokenID()}; + for (int32_t i = 0; i <= PERMS_LIST_SIZE_MAX_TEST; i++) { // 1025 is a invalid size + scopeInfo.permList.emplace_back("ohos.permission.MICROPHONE"); + if (i == PERMS_LIST_SIZE_MAX_TEST) { // 1025 is a invalid size + auto callbackPtr = std::make_shared(scopeInfo); + int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, res); + break; + } + auto callbackPtr = std::make_shared(scopeInfo); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr)); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr)); + } + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); +} + +/** + * @tc.name: RegisterSelfPermStateChangeCallback007 + * @tc.desc: RegisterSelfPermStateChangeCallback without set TokenID. + * @tc.type: FUNC + * @tc.require: issueI5NT1X + */ +HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterSelfPermStateChangeCallback007, TestSize.Level1) +{ + static HapPolicyParams infoManagerTestPolicyPrams1 = { + .apl = APL_NORMAL, + .domain = "test.domain2", + .permList = {}, + .permStateList = {g_infoManagerTestStateA} + }; + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ(RET_SUCCESS, + TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1, tokenIdEx)); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + + PermStateChangeScope scopeInfo; + scopeInfo.permList = {"ohos.permission.CAMERA"}; + scopeInfo.tokenIDs = {tokenID}; + auto callbackPtr = std::make_shared(scopeInfo); + callbackPtr->ready_ = false; + + int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, res); + + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); +} + +/** + * @tc.name: RegisterSelfPermStateChangeCallback008 + * @tc.desc: RegisterSelfPermStateChangeCallback with none or two tokenIDs. + * @tc.type: FUNC + * @tc.require: issueI5NT1X + */ +HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterSelfPermStateChangeCallback008, TestSize.Level1) +{ + static HapPolicyParams infoManagerTestPolicyPrams1 = { + .apl = APL_NORMAL, + .domain = "test.domain2", + .permStateList = {g_infoManagerTestStateA} + }; + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ(RET_SUCCESS, + TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1, tokenIdEx)); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + + HapInfoParams infoManagerTestInfoParms2 = { + .userID = 1, + .bundleName = "accesstoken_test_2", + .instIndex = 0, + .appIDDesc = "test2", + .apiVersion = TestCommon::DEFAULT_API_VERSION + }; + + ASSERT_EQ(RET_SUCCESS, + TestCommon::AllocTestHapToken(infoManagerTestInfoParms2, infoManagerTestPolicyPrams1, tokenIdEx)); + AccessTokenID tokenID2 = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID2); + + PermStateChangeScope scopeInfo; + scopeInfo.permList = {"ohos.permission.CAMERA"}; + scopeInfo.tokenIDs = {}; + auto callbackPtr1 = std::make_shared(scopeInfo); + callbackPtr1->ready_ = false; + + // tokenIDs size si 0, + int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr1); + ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, res); + + scopeInfo.tokenIDs = {tokenID, tokenID2}; + auto callbackPtr = std::make_shared(scopeInfo); + callbackPtr->ready_ = false; + + // tokenIDs size != 1 + res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, res); + + SetSelfTokenID(g_selfShellTokenId); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID2)); +} + +/** + * @tc.name: RegisterSelfPermStateChangeCallback009 + * @tc.desc: RegisterSelfPermStateChangeCallback + * @tc.type: FUNC + * @tc.require: issueI5NT1X + */ +HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterSelfPermStateChangeCallback009, TestSize.Level1) +{ + static HapPolicyParams infoManagerTestPolicyPrams1 = { + .apl = APL_NORMAL, + .domain = "test.domain2", + .permList = {}, + .permStateList = {g_infoManagerTestStateA} + }; + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ(RET_SUCCESS, + TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1, tokenIdEx)); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + SetSelfTokenID(tokenID); + + PermStateChangeScope scopeInfo; + scopeInfo.permList = {}; + scopeInfo.tokenIDs = {tokenID}; + std::vector> callbackList; + + for (int32_t i = 0; i < MAX_CALLBACK_MAP_SIZE; i++) { // 200 is the max size + if (i == MAX_CALLBACK_MAP_SIZE) { // 200 is the max size + auto callbackPtr = std::make_shared(scopeInfo); + int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(AccessTokenError::ERR_CALLBACKS_EXCEED_LIMITATION, res); + break; + } + auto callbackPtr = std::make_shared(scopeInfo); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr)); + callbackList.emplace_back(callbackPtr); + } + for (int32_t i = 0; i < MAX_CALLBACK_MAP_SIZE; i++) { // release 200 callback + auto callbackPtr = callbackList[i]; + int32_t res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, res); + } + callbackList.clear(); + + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); +} + +/** + * @tc.name: RegisterSelfPermStateChangeCallback010 + * @tc.desc: RegisterSelfPermStateChangeCallback with nullptr + * @tc.type: FUNC + * @tc.require: issueI5NT1X + */ +HWTEST_F(RegisterPermStateChangeCallbackTest, RegisterSelfPermStateChangeCallback010, TestSize.Level1) +{ + int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(nullptr); + ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, res); +} } // namespace AccessToken } // namespace Security } // namespace OHOS diff --git a/interfaces/innerkits/accesstoken/test/unittest/RegisterCallbackTest/register_perm_state_change_callback_test.h b/interfaces/innerkits/accesstoken/test/unittest/RegisterCallbackTest/register_perm_state_change_callback_test.h index 86efdcc1efb064c2a8f634a53023276cdce7c993..e206be78d5ffdbe8e50792cd24e7f58e38b4cc4e 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/RegisterCallbackTest/register_perm_state_change_callback_test.h +++ b/interfaces/innerkits/accesstoken/test/unittest/RegisterCallbackTest/register_perm_state_change_callback_test.h @@ -32,10 +32,6 @@ public: static void TearDownTestCase(); void SetUp(); void TearDown(); - void AllocHapToken(std::vector& permissionDefs, - std::vector& permissionStateFulls, int32_t apiVersion); - - uint64_t selfTokenId_; }; } // namespace AccessToken } // namespace Security diff --git a/interfaces/innerkits/accesstoken/test/unittest/RegisterCallbackTest/un_register_perm_state_change_callback_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/RegisterCallbackTest/un_register_perm_state_change_callback_test.cpp index 12d3f419d9a32c92498dec7d0fd89a670f2b627f..d3338ef368881f63e0b81766a2249fa60e8e5313 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/RegisterCallbackTest/un_register_perm_state_change_callback_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/RegisterCallbackTest/un_register_perm_state_change_callback_test.cpp @@ -36,99 +36,37 @@ namespace OHOS { namespace Security { namespace AccessToken { namespace { -static const std::string TEST_BUNDLE_NAME = "ohos"; -static const int TEST_USER_ID = 0; - -HapInfoParams g_infoManagerTestNormalInfoParms = TestCommon::GetInfoManagerTestNormalInfoParms(); -HapPolicyParams g_infoManagerTestPolicyPrams = TestCommon::GetInfoManagerTestPolicyPrams(); -HapPolicyParams g_infoManagerTestPolicyPramsBak = g_infoManagerTestPolicyPrams; - -HapInfoParams g_locationTestInfo = { - .userID = TEST_USER_ID, - .bundleName = "accesstoken_location_test", - .instIndex = 0, - .appIDDesc = "test2" -}; - +static MockHapToken* g_mock = nullptr; uint64_t g_selfShellTokenId; +HapInfoParams g_infoManagerTestInfoParms = TestCommon::GetInfoManagerTestInfoParms(); } void UnRegisterPermStateChangeCallbackTest::SetUpTestCase() { g_selfShellTokenId = GetSelfTokenID(); - // clean up test cases - AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_infoManagerTestNormalInfoParms.userID, - g_infoManagerTestNormalInfoParms.bundleName, - g_infoManagerTestNormalInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenId); - - tokenId = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenId); - - TestCommon::GetNativeTokenTest(); + TestCommon::SetTestEvironment(g_selfShellTokenId); + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.GET_SENSITIVE_PERMISSIONS"); + g_mock = new (std::nothrow) MockHapToken("UnRegisterPermStateChangeCallbackTest", reqPerm, true); } void UnRegisterPermStateChangeCallbackTest::TearDownTestCase() { + if (g_mock != nullptr) { + delete g_mock; + g_mock = nullptr; + } SetSelfTokenID(g_selfShellTokenId); + TestCommon::ResetTestEvironment(); } void UnRegisterPermStateChangeCallbackTest::SetUp() { - setuid(0); - selfTokenId_ = GetSelfTokenID(); - g_infoManagerTestPolicyPrams = g_infoManagerTestPolicyPramsBak; - HapInfoParams info = { - .userID = TEST_USER_ID, - .bundleName = TEST_BUNDLE_NAME, - .instIndex = 0, - .appIDDesc = "appIDDesc", - .apiVersion = 8, - .isSystemApp = true - }; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "domain" - }; - AccessTokenKit::AllocHapToken(info, policy); LOGI(ATM_DOMAIN, ATM_TAG, "SetUp ok."); } void UnRegisterPermStateChangeCallbackTest::TearDown() { - AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenId); - tokenId = AccessTokenKit::GetHapTokenID(g_infoManagerTestNormalInfoParms.userID, - g_infoManagerTestNormalInfoParms.bundleName, - g_infoManagerTestNormalInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenId); - EXPECT_EQ(0, SetSelfTokenID(selfTokenId_)); -} - -void UnRegisterPermStateChangeCallbackTest::AllocHapToken(std::vector& permissionDefs, - std::vector& permissionStateFulls, int32_t apiVersion) -{ - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, "accesstoken_location_test", 0); - AccessTokenKit::DeleteToken(tokenID); - - HapInfoParams info = g_locationTestInfo; - info.apiVersion = apiVersion; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "domain" - }; - - for (auto& permissionDef:permissionDefs) { - policy.permList.emplace_back(permissionDef); - } - - for (auto& permissionStateFull:permissionStateFulls) { - policy.permStateList.emplace_back(permissionStateFull); - } - - AccessTokenKit::AllocHapToken(info, policy); } class CbCustomizeTest : public PermStateChangeCallbackCustomize { @@ -213,18 +151,407 @@ HWTEST_F(UnRegisterPermStateChangeCallbackTest, UnRegisterPermStateChangeCallbac int32_t res = AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr); ASSERT_EQ(RET_SUCCESS, res); - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestNormalInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); + { + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.GET_SENSITIVE_PERMISSIONS"); + MockHapToken mock("UnRegisterPermStateChangeCallbackFuncTest001", reqPerm, false); - res = AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr); - ASSERT_EQ(ERR_NOT_SYSTEM_APP, res); + res = AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr); + ASSERT_EQ(ERR_NOT_SYSTEM_APP, res); + } - EXPECT_EQ(0, SetSelfTokenID(selfTokenId_)); res = AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr); ASSERT_EQ(RET_SUCCESS, res); } + +/** + * @tc.name: UnRegisterSelfPermStateChangeCallback001 + * @tc.desc: UnRegisterSelfPermStateChangeCallback with invalid input. + * @tc.type: FUNC + * @tc.require: issueI5NT1X + */ +HWTEST_F(UnRegisterPermStateChangeCallbackTest, UnRegisterSelfPermStateChangeCallback001, TestSize.Level1) +{ + static PermissionStateFull infoManagerTestStateA = { + .permissionName = "ohos.permission.CAMERA", + .isGeneral = true, + .resDeviceID = {"local2"}, + .grantStatus = {PERMISSION_DENIED}, + .grantFlags = {1} + }; + static HapPolicyParams infoManagerTestPolicyPrams1 = { + .apl = APL_NORMAL, + .domain = "test.domain2", + .permStateList = {infoManagerTestStateA} + }; + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ(RET_SUCCESS, + TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1, tokenIdEx)); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + + PermStateChangeScope scopeInfo; + scopeInfo.permList = {}; + scopeInfo.tokenIDs = {tokenID}; + auto callbackPtr = std::make_shared(scopeInfo); + callbackPtr->ready_ = false; + + SetSelfTokenID(tokenID); + int32_t res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(AccessTokenError::ERR_INTERFACE_NOT_USED_TOGETHER, res); + + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); + SetSelfTokenID(g_selfShellTokenId); +} + +/** + * @tc.name: UnRegisterSelfPermStateChangeCallback002 + * @tc.desc: UnRegisterSelfPermStateChangeCallback repeatedly. + * @tc.type: FUNC + * @tc.require: issueI5NT1X + */ +HWTEST_F(UnRegisterPermStateChangeCallbackTest, UnRegisterSelfPermStateChangeCallback002, TestSize.Level1) +{ + static PermissionStateFull infoManagerTestStateA = { + .permissionName = "ohos.permission.CAMERA", + .isGeneral = true, + .resDeviceID = {"local2"}, + .grantStatus = {PERMISSION_DENIED}, + .grantFlags = {1} + }; + static HapPolicyParams infoManagerTestPolicyPrams1 = { + .apl = APL_NORMAL, + .domain = "test.domain2", + .permStateList = {infoManagerTestStateA} + }; + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ(RET_SUCCESS, + TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1, tokenIdEx)); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + + PermStateChangeScope scopeInfo; + scopeInfo.permList = {}; + scopeInfo.tokenIDs = {tokenID}; + auto callbackPtr = std::make_shared(scopeInfo); + callbackPtr->ready_ = false; + + SetSelfTokenID(tokenID); + int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, res); + res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(AccessTokenError::ERR_CALLBACK_ALREADY_EXIST, res); + res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, res); + res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(AccessTokenError::ERR_INTERFACE_NOT_USED_TOGETHER, res); + SetSelfTokenID(g_selfShellTokenId); + + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); +} + +/** + * @tc.name: UnRegisterSelfPermStateChangeCallback003 + * @tc.desc: UnRegisterSelfPermStateChangeCallback permList + * @tc.type: FUNC + * @tc.require: issueI5NT1X + */ +HWTEST_F(UnRegisterPermStateChangeCallbackTest, UnRegisterSelfPermStateChangeCallback003, TestSize.Level1) +{ + static PermissionStateFull infoManagerTestStateA = { + .permissionName = "ohos.permission.CAMERA", + .isGeneral = true, + .resDeviceID = {"local2"}, + .grantStatus = {PERMISSION_DENIED}, + .grantFlags = {1} + }; + static HapPolicyParams infoManagerTestPolicyPrams1 = { + .apl = APL_NORMAL, + .domain = "test.domain2", + .permStateList = {infoManagerTestStateA} + }; + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ(RET_SUCCESS, + TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1, tokenIdEx)); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + + PermStateChangeScope scopeInfo; + scopeInfo.permList = {"ohos.permission.CAMERA"}; + scopeInfo.tokenIDs = {tokenID}; + auto callbackPtr = std::make_shared(scopeInfo); + callbackPtr->ready_ = false; + + SetSelfTokenID(tokenID); + int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, res); + + res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, res); + SetSelfTokenID(g_selfShellTokenId); + + callbackPtr->ready_ = false; + + res = TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.CAMERA", 2); + ASSERT_EQ(RET_SUCCESS, res); + usleep(500000); // 500000us = 0.5s + ASSERT_EQ(false, callbackPtr->ready_); + + callbackPtr->ready_ = false; + + res = TestCommon::RevokePermissionByTest(tokenID, "ohos.permission.CAMERA", 2); + ASSERT_EQ(RET_SUCCESS, res); + usleep(500000); // 500000us = 0.5s + ASSERT_EQ(false, callbackPtr->ready_); + + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); +} + +/** + * @tc.name: UnRegisterSelfPermStateChangeCallback004 + * @tc.desc: UnRegisterSelfPermStateChangeCallback permList + * @tc.type: FUNC + * @tc.require: issueI5NT1X + */ +HWTEST_F(UnRegisterPermStateChangeCallbackTest, UnRegisterSelfPermStateChangeCallback004, TestSize.Level1) +{ + static PermissionStateFull infoManagerTestStateA = { + .permissionName = "ohos.permission.CAMERA", + .isGeneral = true, + .resDeviceID = {"local2"}, + .grantStatus = {PERMISSION_DENIED}, + .grantFlags = {1} + }; + static PermissionStateFull infoManagerTestStateB = { + .permissionName = "ohos.permission.GET_BUNDLE_INFO", + .isGeneral = true, + .resDeviceID = {"local2"}, + .grantStatus = {PERMISSION_DENIED}, + .grantFlags = {1} + }; + static HapPolicyParams infoManagerTestPolicyPrams1 = { + .apl = APL_NORMAL, + .domain = "test.domain2", + .permStateList = {infoManagerTestStateA, infoManagerTestStateB} + }; + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ(RET_SUCCESS, + TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1, tokenIdEx)); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + + PermStateChangeScope scopeInfo; + scopeInfo.permList = {"ohos.permission.CAMERA"}; + scopeInfo.tokenIDs = {tokenID}; + auto callbackPtr = std::make_shared(scopeInfo); + callbackPtr->ready_ = false; + + SetSelfTokenID(tokenID); + int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, res); + + res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, res); + SetSelfTokenID(g_selfShellTokenId); + + callbackPtr->ready_ = false; + + res = TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.CAMERA", 2); + ASSERT_EQ(RET_SUCCESS, res); + usleep(500000); // 500000us = 0.5s + ASSERT_EQ(false, callbackPtr->ready_); + + callbackPtr->ready_ = false; + + res = TestCommon::RevokePermissionByTest(tokenID, "ohos.permission.CAMERA", 2); + ASSERT_EQ(RET_SUCCESS, res); + usleep(500000); // 500000us = 0.5s + ASSERT_EQ(false, callbackPtr->ready_); + + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); +} + +/** + * @tc.name: UnRegisterSelfPermStateChangeCallback005 + * @tc.desc: UnRegisterSelfPermStateChangeCallback permList + * @tc.type: FUNC + * @tc.require: issueI5NT1X + */ +HWTEST_F(UnRegisterPermStateChangeCallbackTest, UnRegisterSelfPermStateChangeCallback005, TestSize.Level1) +{ + static PermissionStateFull infoManagerTestStateA = { + .permissionName = "ohos.permission.CAMERA", + .isGeneral = true, + .resDeviceID = {"local2"}, + .grantStatus = {PERMISSION_DENIED}, + .grantFlags = {1} + }; + static HapPolicyParams infoManagerTestPolicyPrams1 = { + .apl = APL_NORMAL, + .domain = "test.domain2", + .permStateList = {infoManagerTestStateA} + }; + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ(RET_SUCCESS, + TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1, tokenIdEx)); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + + PermStateChangeScope scopeInfo; + scopeInfo.permList = {}; + scopeInfo.tokenIDs = {tokenID}; + auto callbackPtr = std::make_shared(scopeInfo); + callbackPtr->ready_ = false; + + SetSelfTokenID(tokenID); + int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, res); + SetSelfTokenID(g_selfShellTokenId); + + SetSelfTokenID(tokenID); + res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, res); + SetSelfTokenID(g_selfShellTokenId); + + callbackPtr->ready_ = false; + + res = TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.CAMERA", 2); + ASSERT_EQ(RET_SUCCESS, res); + usleep(500000); // 500000us = 0.5s + ASSERT_EQ(false, callbackPtr->ready_); + + callbackPtr->ready_ = false; + + res = TestCommon::RevokePermissionByTest(tokenID, "ohos.permission.CAMERA", 2); + ASSERT_EQ(RET_SUCCESS, res); + usleep(500000); // 500000us = 0.5s + ASSERT_EQ(false, callbackPtr->ready_); + + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); +} + +/** + * @tc.name: UnRegisterSelfPermStateChangeCallback006 + * @tc.desc: UnRegisterSelfPermStateChangeCallback permList + * @tc.type: FUNC + * @tc.require: issueI5NT1X + */ +HWTEST_F(UnRegisterPermStateChangeCallbackTest, UnRegisterSelfPermStateChangeCallback006, TestSize.Level1) +{ + static PermissionStateFull infoManagerTestStateA = { + .permissionName = "ohos.permission.CAMERA", + .isGeneral = true, + .resDeviceID = {"local2"}, + .grantStatus = {PERMISSION_DENIED}, + .grantFlags = {1} + }; + static PermissionStateFull infoManagerTestStateB = { + .permissionName = "ohos.permission.DISTRIBUTED_DATASYNC", + .isGeneral = true, + .resDeviceID = {"local2"}, + .grantStatus = {PERMISSION_DENIED}, + .grantFlags = {1} + }; + static HapPolicyParams infoManagerTestPolicyPrams1 = { + .apl = APL_NORMAL, + .domain = "test.domain2", + .permStateList = {infoManagerTestStateA, infoManagerTestStateB} + }; + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ(RET_SUCCESS, + TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1, tokenIdEx)); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + + PermStateChangeScope scopeInfo; + scopeInfo.permList = {"ohos.permission.CAMERA", "ohos.permission.DISTRIBUTED_DATASYNC"}; + scopeInfo.tokenIDs = {tokenID}; + auto callbackPtr = std::make_shared(scopeInfo); + callbackPtr->ready_ = false; + + SetSelfTokenID(tokenID); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr)); + + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr)); + SetSelfTokenID(g_selfShellTokenId); + + callbackPtr->ready_ = false; + + ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.CAMERA", 2)); + usleep(500000); // 500000us = 0.5s + ASSERT_EQ(false, callbackPtr->ready_); + + ASSERT_EQ(RET_SUCCESS, TestCommon::RevokePermissionByTest(tokenID, "ohos.permission.CAMERA", 2)); + usleep(500000); // 500000us = 0.5s + ASSERT_EQ(false, callbackPtr->ready_); + + ASSERT_EQ(RET_SUCCESS, TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.DISTRIBUTED_DATASYNC", 2)); + usleep(500000); // 500000us = 0.5s + ASSERT_EQ(false, callbackPtr->ready_); + + ASSERT_EQ(RET_SUCCESS, TestCommon::RevokePermissionByTest(tokenID, "ohos.permission.DISTRIBUTED_DATASYNC", 2)); + usleep(500000); // 500000us = 0.5s + ASSERT_EQ(false, callbackPtr->ready_); + + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); +} + +/** + * @tc.name: UnRegisterSelfPermStateChangeCallback007 + * @tc.desc: UnRegisterSelfPermStateChangeCallback permList + * @tc.type: FUNC + * @tc.require: issueI5NT1X + */ +HWTEST_F(UnRegisterPermStateChangeCallbackTest, UnRegisterSelfPermStateChangeCallback007, TestSize.Level1) +{ + static PermissionStateFull infoManagerTestStateA = { + .permissionName = "ohos.permission.CAMERA", + .isGeneral = true, + .resDeviceID = {"local2"}, + .grantStatus = {PERMISSION_DENIED}, + .grantFlags = {1} + }; + static HapPolicyParams infoManagerTestPolicyPrams1 = { + .apl = APL_NORMAL, + .domain = "test.domain2", + .permStateList = {infoManagerTestStateA} + }; + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ(RET_SUCCESS, + TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1, tokenIdEx)); + AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenID); + + PermStateChangeScope scopeInfo; + scopeInfo.permList = {"ohos.permission.INVALID", "ohos.permission.CAMERA"}; + scopeInfo.tokenIDs = {tokenID}; + auto callbackPtr = std::make_shared(scopeInfo); + callbackPtr->ready_ = false; + + SetSelfTokenID(tokenID); + int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, res); + + res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr); + ASSERT_EQ(RET_SUCCESS, res); + SetSelfTokenID(g_selfShellTokenId); + + callbackPtr->ready_ = false; + + res = TestCommon::GrantPermissionByTest(tokenID, "ohos.permission.CAMERA", 2); + ASSERT_EQ(RET_SUCCESS, res); + usleep(500000); // 500000us = 0.5s + ASSERT_EQ(false, callbackPtr->ready_); + + callbackPtr->ready_ = false; + + res = TestCommon::RevokePermissionByTest(tokenID, "ohos.permission.CAMERA", 2); + ASSERT_EQ(RET_SUCCESS, res); + usleep(500000); // 500000us = 0.5s + ASSERT_EQ(false, callbackPtr->ready_); + + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenID)); +} } // namespace AccessToken } // namespace Security } // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/accesstoken/test/unittest/RegisterCallbackTest/un_register_perm_state_change_callback_test.h b/interfaces/innerkits/accesstoken/test/unittest/RegisterCallbackTest/un_register_perm_state_change_callback_test.h index b10ed24d7b195c06a856eefe84ea5367679c3596..3bffaa941ace01d5757b2ff46eec4facf7419e20 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/RegisterCallbackTest/un_register_perm_state_change_callback_test.h +++ b/interfaces/innerkits/accesstoken/test/unittest/RegisterCallbackTest/un_register_perm_state_change_callback_test.h @@ -32,10 +32,6 @@ public: static void TearDownTestCase(); void SetUp(); void TearDown(); - void AllocHapToken(std::vector& permissionDefs, - std::vector& permissionStateFulls, int32_t apiVersion); - - uint64_t selfTokenId_; }; } // namespace AccessToken } // namespace Security diff --git a/interfaces/innerkits/accesstoken/test/unittest/SaTest/dump_token_info_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/SaTest/dump_token_info_test.cpp index 66323f1c32017aa0797ba0b0e7af68cfff1bb2e7..c79322656a16294d2de42c1b4806685e906fad85 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/SaTest/dump_token_info_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/SaTest/dump_token_info_test.cpp @@ -34,9 +34,8 @@ namespace OHOS { namespace Security { namespace AccessToken { namespace { -static AccessTokenID g_selfTokenId = 0; +static uint64_t g_selfTokenId = 0; static const std::string TEST_BUNDLE_NAME = "ohos"; -static AccessTokenIDEx g_testTokenIDEx = {0}; static int32_t g_selfUid; static HapPolicyParams g_PolicyPrams = { @@ -57,12 +56,14 @@ void DumpTokenInfoTest::SetUpTestCase() { g_selfTokenId = GetSelfTokenID(); g_selfUid = getuid(); + TestCommon::SetTestEvironment(g_selfTokenId); } void DumpTokenInfoTest::TearDownTestCase() { setuid(g_selfUid); SetSelfTokenID(g_selfTokenId); + TestCommon::ResetTestEvironment(); } void DumpTokenInfoTest::SetUp() @@ -85,17 +86,14 @@ void DumpTokenInfoTest::TearDown() HWTEST_F(DumpTokenInfoTest, DumpTokenInfoAbnormalTest001, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "DumpTokenInfoAbnormalTest001"); - AccessTokenKit::AllocHapToken(g_InfoParms, g_PolicyPrams); + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ(RET_SUCCESS, TestCommon::AllocTestHapToken(g_InfoParms, g_PolicyPrams, tokenIdEx)); + ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIdExStruct.tokenID); - g_testTokenIDEx = AccessTokenKit::GetHapTokenIDEx(g_InfoParms.userID, - g_InfoParms.bundleName, - g_InfoParms.instIndex); - ASSERT_NE(INVALID_TOKENID, g_testTokenIDEx.tokenIDEx); setuid(g_selfUid); - EXPECT_EQ(0, SetSelfTokenID(g_testTokenIDEx.tokenIDEx)); + EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); setuid(1234); // 1234: UID - std::string dumpInfo; AtmToolsParamInfo info; info.tokenId = 123; @@ -105,6 +103,8 @@ HWTEST_F(DumpTokenInfoTest, DumpTokenInfoAbnormalTest001, TestSize.Level1) setuid(g_selfUid); EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId)); setuid(g_selfUid); + + ASSERT_EQ(RET_SUCCESS, TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID)); } /** diff --git a/interfaces/innerkits/accesstoken/test/unittest/SaTest/get_native_token_id_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/SaTest/get_native_token_id_test.cpp index 42e2a0bee980522aa691f905c5b918d14c45ae8e..2f910f59b997db3f68a093197c08857f9af05169 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/SaTest/get_native_token_id_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/SaTest/get_native_token_id_test.cpp @@ -34,49 +34,24 @@ namespace OHOS { namespace Security { namespace AccessToken { namespace { -static AccessTokenID g_selfTokenId = 0; -static const std::string TEST_BUNDLE_NAME = "ohos"; -static const int TEST_USER_ID = 0; +static uint64_t g_selfTokenId = 0; }; void GetNativeTokenIdTest::SetUpTestCase() { g_selfTokenId = GetSelfTokenID(); - - // clean up test cases - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenID); + TestCommon::SetTestEvironment(g_selfTokenId); } void GetNativeTokenIdTest::TearDownTestCase() { - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenID); - SetSelfTokenID(g_selfTokenId); + TestCommon::ResetTestEvironment(); } void GetNativeTokenIdTest::SetUp() { LOGI(ATM_DOMAIN, ATM_TAG, "SetUp ok."); - - setuid(0); - HapInfoParams info = { - .userID = TEST_USER_ID, - .bundleName = TEST_BUNDLE_NAME, - .instIndex = 0, - .appIDDesc = "appIDDesc", - .apiVersion = 8 - }; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "domain" - }; - TestCommon::TestPreparePermDefList(policy); - TestCommon::TestPreparePermStateList(policy); - - AccessTokenKit::AllocHapToken(info, policy); } void GetNativeTokenIdTest::TearDown() @@ -109,10 +84,8 @@ HWTEST_F(GetNativeTokenIdTest, GetNativeTokenIdAbnormalTest002, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "GetNativeTokenIdAbnormalTest002"); std::string processName = "hdcd"; - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); - ASSERT_EQ(RET_SUCCESS, SetSelfTokenID(tokenID)); - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::ReloadNativeTokenInfo()); + std::vector reqPerm; + MockHapToken mock("GetNativeTokenIdAbnormalTest002", reqPerm, true); int32_t selfUid = getuid(); setuid(10001); // 10001： UID @@ -121,7 +94,6 @@ HWTEST_F(GetNativeTokenIdTest, GetNativeTokenIdAbnormalTest002, TestSize.Level1) // restore environment setuid(selfUid); - ASSERT_EQ(RET_SUCCESS, SetSelfTokenID(g_selfTokenId)); } /** @@ -153,6 +125,8 @@ HWTEST_F(GetNativeTokenIdTest, GetNativeTokenIdAbnormalTest003, TestSize.Level1) HWTEST_F(GetNativeTokenIdTest, GetNativeTokenIdFuncTest001, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "GetNativeTokenIdFuncTest001"); + MockNativeToken mock("accesstoken_service"); + std::string processName = "hdcd"; AccessTokenID tokenID = AccessTokenKit::GetNativeTokenId(processName); ASSERT_NE(INVALID_TOKENID, tokenID); @@ -164,7 +138,7 @@ HWTEST_F(GetNativeTokenIdTest, GetNativeTokenIdFuncTest001, TestSize.Level1) /** * @tc.name: GetNativeTokenIdFuncTest002 - * @tc.desc: get native tokenid with hap. + * @tc.desc: get native tokenid. * @tc.type: FUNC * @tc.require: Issue Number */ @@ -172,19 +146,14 @@ HWTEST_F(GetNativeTokenIdTest, GetNativeTokenIdFuncTest002, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "GetNativeTokenIdFuncTest002"); std::string processName = "hdcd"; - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); - ASSERT_EQ(0, SetSelfTokenID(tokenID)); - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::ReloadNativeTokenInfo()); + MockNativeToken mock("accesstoken_service"); - tokenID = AccessTokenKit::GetNativeTokenId(processName); + AccessTokenID tokenID = AccessTokenKit::GetNativeTokenId(processName); ASSERT_NE(INVALID_TOKENID, tokenID); NativeTokenInfo tokenInfo; ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GetNativeTokenInfo(tokenID, tokenInfo)); ASSERT_EQ(true, tokenInfo.processName == processName); - - ASSERT_EQ(0, SetSelfTokenID(g_selfTokenId)); } } // namespace AccessToken } // namespace Security diff --git a/interfaces/innerkits/accesstoken/test/unittest/SaTest/get_native_token_info_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/SaTest/get_native_token_info_test.cpp index 413cbe9f444135f83edc634ffe1169ec320e509a..ada8b705aa8a63d017b6d2809b8a3c79a3d1d1e9 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/SaTest/get_native_token_info_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/SaTest/get_native_token_info_test.cpp @@ -34,7 +34,7 @@ namespace OHOS { namespace Security { namespace AccessToken { namespace { -static AccessTokenID g_selfTokenId = 0; +static uint64_t g_selfTokenId = 0; static const std::string TEST_BUNDLE_NAME = "ohos"; static const int TEST_USER_ID = 0; static int32_t g_selfUid; @@ -43,18 +43,20 @@ static int32_t g_selfUid; void GetNativeTokenInfoTest::SetUpTestCase() { g_selfTokenId = GetSelfTokenID(); + TestCommon::SetTestEvironment(g_selfTokenId); // clean up test cases - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenID); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID); } void GetNativeTokenInfoTest::TearDownTestCase() { - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenID); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID); SetSelfTokenID(g_selfTokenId); + TestCommon::ResetTestEvironment(); } void GetNativeTokenInfoTest::SetUp() @@ -74,38 +76,68 @@ void GetNativeTokenInfoTest::SetUp() .apl = APL_NORMAL, .domain = "domain" }; - TestCommon::TestPreparePermDefList(policy); - TestCommon::TestPreparePermStateList(policy); - - AccessTokenKit::AllocHapToken(info, policy); + AccessTokenIDEx tokenIdEx = {0}; + ASSERT_EQ(RET_SUCCESS, TestCommon::AllocTestHapToken(info, policy, tokenIdEx)); + ASSERT_NE(tokenIdEx.tokenIdExStruct.tokenID, INVALID_TOKENID); } void GetNativeTokenInfoTest::TearDown() { + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID); } /** * @tc.name: GetNativeTokenInfoAbnormalTest001 - * @tc.desc: cannot get native token with invalid tokenID. + * @tc.desc: cannot get native token with invalid tokenID(0). * @tc.type: FUNC * @tc.require: Issue Number */ -HWTEST_F(GetNativeTokenInfoTest, GetNativeTokenInfoAbnormalTest001, TestSize.Level1) +HWTEST_F(GetNativeTokenInfoTest, GeTokenInfoAbnormalTest001, TestSize.Level1) { - LOGI(ATM_DOMAIN, ATM_TAG, "GetNativeTokenInfoAbnormalTest001"); + LOGI(ATM_DOMAIN, ATM_TAG, "GeTokenInfoAbnormalTest001"); AccessTokenID tokenID = 0; - NativeTokenInfo findInfo; - int ret = AccessTokenKit::GetNativeTokenInfo(tokenID, findInfo); - ASSERT_EQ(ret, AccessTokenError::ERR_PARAM_INVALID); + NativeTokenInfo nativeInfo; + ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, AccessTokenKit::GetNativeTokenInfo(tokenID, nativeInfo)); + + HapTokenInfo hapInfo; + ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, AccessTokenKit::GetHapTokenInfo(tokenID, hapInfo)); } /** - * @tc.name: GetNativeTokenInfoAbnormalTest002 + * @tc.name: GetTokenInfoAbnormalTest002 + * @tc.desc: 1. cannot get native token with invalid tokenID(hap); 1. cannot get hap token with invalid tokenID(native) + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(GetNativeTokenInfoTest, GetTokenInfoAbnormalTest002, TestSize.Level1) +{ + LOGI(ATM_DOMAIN, ATM_TAG, "GetNativeTokenInfoAbnormalTest002"); + MockNativeToken mock("accesstoken_service"); + + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenHap = tokenIdEx.tokenIdExStruct.tokenID; + ASSERT_NE(INVALID_TOKENID, tokenHap); + AccessTokenID tokenNative = AccessTokenKit::GetNativeTokenId("token_sync_service"); + ASSERT_NE(INVALID_TOKENID, tokenNative); + + NativeTokenInfo nativeInfo; + HapTokenInfo hapInfo; + ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, AccessTokenKit::GetNativeTokenInfo(tokenHap, nativeInfo)); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GetHapTokenInfo(tokenHap, hapInfo)); + + + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GetNativeTokenInfo(tokenNative, nativeInfo)); + ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, AccessTokenKit::GetHapTokenInfo(tokenNative, hapInfo)); +} + +/** + * @tc.name: GetTokenInfoAbnormalTest003 * @tc.desc: GetNativeTokenInfo with no permission * @tc.type: FUNC * @tc.require: */ -HWTEST_F(GetNativeTokenInfoTest, GetNativeTokenInfoAbnormalTest002, TestSize.Level1) +HWTEST_F(GetNativeTokenInfoTest, GetTokenInfoAbnormalTest003, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "GetNativeTokenInfoAbnormalTest002"); g_selfUid = getuid(); @@ -115,37 +147,38 @@ HWTEST_F(GetNativeTokenInfoTest, GetNativeTokenInfoAbnormalTest002, TestSize.Lev NativeTokenInfo tokenInfo; ASSERT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, AccessTokenKit::GetNativeTokenInfo(tokenId, tokenInfo)); + HapTokenInfo hapInfo; + ASSERT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, AccessTokenKit::GetNativeTokenInfo(tokenId, tokenInfo)); + setuid(g_selfUid); } /** * @tc.name: GetNativeTokenInfoFuncTest001 - * @tc.desc: Get native token info success. + * @tc.desc: Get token info success. * @tc.type: FUNC * @tc.require: Issue Number */ HWTEST_F(GetNativeTokenInfoTest, GetNativeTokenInfoFuncTest001, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "GetNativeTokenInfoFuncTest001"); - AccessTokenID tokenHap = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + MockNativeToken mock("accesstoken_service"); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(TEST_USER_ID, TEST_BUNDLE_NAME, 0); + AccessTokenID tokenHap = tokenIdEx.tokenIdExStruct.tokenID; ASSERT_NE(INVALID_TOKENID, tokenHap); - NativeTokenInfo nativeInfo; - HapTokenInfo hapInfo; - - int ret = AccessTokenKit::GetHapTokenInfo(tokenHap, hapInfo); - ASSERT_EQ(ret, RET_SUCCESS); - AccessTokenID tokenNative = AccessTokenKit::GetNativeTokenId("token_sync_service"); ASSERT_NE(INVALID_TOKENID, tokenNative); - ret = AccessTokenKit::GetNativeTokenInfo(tokenNative, nativeInfo); - ASSERT_EQ(ret, RET_SUCCESS); + NativeTokenInfo nativeInfo; + HapTokenInfo hapInfo; + + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GetHapTokenInfo(tokenHap, hapInfo)); + ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GetNativeTokenInfo(tokenNative, nativeInfo)); - ret = AccessTokenKit::GetHapTokenInfo(tokenNative, hapInfo); - ASSERT_EQ(ret, AccessTokenError::ERR_PARAM_INVALID); - AccessTokenKit::DeleteToken(tokenHap); + ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, AccessTokenKit::GetNativeTokenInfo(tokenHap, nativeInfo)); + ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, AccessTokenKit::GetHapTokenInfo(tokenNative, hapInfo)); } } // namespace AccessToken } // namespace Security diff --git a/interfaces/innerkits/accesstoken/test/unittest/SaTest/get_version_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/SaTest/get_version_test.cpp index a0bc0ba355b09111e7f13fdc7958477b6c411422..eb6c1343d7857bdd0a6abafecab8de5be25736fa 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/SaTest/get_version_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/SaTest/get_version_test.cpp @@ -36,136 +36,28 @@ namespace OHOS { namespace Security { namespace AccessToken { namespace { -static const std::string TEST_BUNDLE_NAME = "ohos"; -static const int TEST_USER_ID = 0; - -HapInfoParams g_locationTestInfo = { - .userID = TEST_USER_ID, - .bundleName = "accesstoken_location_test", - .instIndex = 0, - .appIDDesc = "test2" -}; - -HapInfoParams g_infoManagerTestNormalInfoParms = TestCommon::GetInfoManagerTestNormalInfoParms(); -HapInfoParams g_infoManagerTestSystemInfoParms = TestCommon::GetInfoManagerTestSystemInfoParms(); -HapPolicyParams g_infoManagerTestPolicyPrams = TestCommon::GetInfoManagerTestPolicyPrams(); -HapPolicyParams g_infoManagerTestPolicyPramsBak = g_infoManagerTestPolicyPrams; - uint64_t g_selfShellTokenId; } -void GetNativeTokenTest() -{ - uint64_t tokenId; - const char **perms = new const char *[4]; - perms[0] = "ohos.permission.DISTRIBUTED_DATASYNC"; - perms[1] = "ohos.permission.GRANT_SENSITIVE_PERMISSIONS"; - perms[2] = "ohos.permission.REVOKE_SENSITIVE_PERMISSIONS"; // 2 means the second permission - perms[3] = "ohos.permission.GET_SENSITIVE_PERMISSIONS"; // 3 means the third permission - - NativeTokenInfoParams infoInstance = { - .dcapsNum = 0, - .permsNum = 4, - .aclsNum = 0, - .dcaps = nullptr, - .perms = perms, - .acls = nullptr, - .aplStr = "system_core", - }; - - infoInstance.processName = "TestCase"; - tokenId = GetAccessTokenId(&infoInstance); - EXPECT_EQ(0, SetSelfTokenID(tokenId)); - AccessTokenKit::ReloadNativeTokenInfo(); - delete[] perms; -} - void GetVersionTest::SetUpTestCase() { g_selfShellTokenId = GetSelfTokenID(); - // clean up test cases - AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_infoManagerTestNormalInfoParms.userID, - g_infoManagerTestNormalInfoParms.bundleName, - g_infoManagerTestNormalInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenId); - - tokenId = AccessTokenKit::GetHapTokenID(g_infoManagerTestSystemInfoParms.userID, - g_infoManagerTestSystemInfoParms.bundleName, - g_infoManagerTestSystemInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenId); - - tokenId = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenId); - - GetNativeTokenTest(); + TestCommon::SetTestEvironment(g_selfShellTokenId); } void GetVersionTest::TearDownTestCase() { SetSelfTokenID(g_selfShellTokenId); + TestCommon::ResetTestEvironment(); } void GetVersionTest::SetUp() { - setuid(0); - selfTokenId_ = GetSelfTokenID(); - g_infoManagerTestPolicyPrams = g_infoManagerTestPolicyPramsBak; - HapInfoParams info = { - .userID = TEST_USER_ID, - .bundleName = TEST_BUNDLE_NAME, - .instIndex = 0, - .appIDDesc = "appIDDesc", - .apiVersion = 8, - .isSystemApp = true - }; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "domain" - }; - AccessTokenKit::AllocHapToken(info, policy); LOGI(ATM_DOMAIN, ATM_TAG, "SetUp ok."); } void GetVersionTest::TearDown() { - AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenId); - tokenId = AccessTokenKit::GetHapTokenID(g_infoManagerTestNormalInfoParms.userID, - g_infoManagerTestNormalInfoParms.bundleName, - g_infoManagerTestNormalInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenId); - - tokenId = AccessTokenKit::GetHapTokenID(g_infoManagerTestSystemInfoParms.userID, - g_infoManagerTestSystemInfoParms.bundleName, - g_infoManagerTestSystemInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenId); - EXPECT_EQ(0, SetSelfTokenID(selfTokenId_)); -} - -void GetVersionTest::AllocHapToken(std::vector& permissionDefs, - std::vector& permissionStateFulls, int32_t apiVersion) -{ - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, "accesstoken_location_test", 0); - AccessTokenKit::DeleteToken(tokenID); - - HapInfoParams info = g_locationTestInfo; - info.apiVersion = apiVersion; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "domain" - }; - - for (auto& permissionDef:permissionDefs) { - policy.permList.emplace_back(permissionDef); - } - - for (auto& permissionStateFull:permissionStateFulls) { - policy.permStateList.emplace_back(permissionStateFull); - } - - AccessTokenKit::AllocHapToken(info, policy); } /** @@ -177,14 +69,11 @@ void GetVersionTest::AllocHapToken(std::vector& permissionDefs, HWTEST_F(GetVersionTest, GetVersionFuncTest001, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "GetVersionFuncTest001"); - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestNormalInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); + std::vector reqPerm; + MockHapToken mock("GetVersionFuncTest001", reqPerm, false); uint32_t version; - int32_t res = AccessTokenKit::GetVersion(version); - ASSERT_EQ(ERR_NOT_SYSTEM_APP, res); + ASSERT_EQ(ERR_NOT_SYSTEM_APP, AccessTokenKit::GetVersion(version)); } /** @@ -196,10 +85,8 @@ HWTEST_F(GetVersionTest, GetVersionFuncTest001, TestSize.Level1) HWTEST_F(GetVersionTest, GetVersionFuncTest002, TestSize.Level1) { LOGI(ATM_DOMAIN, ATM_TAG, "GetVersionFuncTest002"); - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestSystemInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); + std::vector reqPerm; + MockHapToken mock("GetVersionFuncTest002", reqPerm, true); uint32_t version; int32_t res = AccessTokenKit::GetVersion(version); diff --git a/interfaces/innerkits/accesstoken/test/unittest/SaTest/get_version_test.h b/interfaces/innerkits/accesstoken/test/unittest/SaTest/get_version_test.h index 88bc061811f053cb5e3972f5bc0b9be149fae08e..8cfb18a89c26bf9f5253a75aab20fd3414a0c4c1 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/SaTest/get_version_test.h +++ b/interfaces/innerkits/accesstoken/test/unittest/SaTest/get_version_test.h @@ -32,10 +32,6 @@ public: static void TearDownTestCase(); void SetUp(); void TearDown(); - void AllocHapToken(std::vector& permissionDefs, - std::vector& permissionStateFulls, int32_t apiVersion); - - uint64_t selfTokenId_; }; } // namespace AccessToken } // namespace Security diff --git a/interfaces/innerkits/accesstoken/test/unittest/src/security_component_grant_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/SecurityComponentTest/security_component_grant_test.cpp similarity index 69% rename from interfaces/innerkits/accesstoken/test/unittest/src/security_component_grant_test.cpp rename to interfaces/innerkits/accesstoken/test/unittest/SecurityComponentTest/security_component_grant_test.cpp index 6b00f84e5d6eda79e13a5550b347180cff08c87a..3f535fb8d36a73e0ca1c881391cb3b0b99951244 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/src/security_component_grant_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/SecurityComponentTest/security_component_grant_test.cpp @@ -20,18 +20,17 @@ #include "access_token_error.h" #include "permission_grant_info.h" #include "nativetoken_kit.h" +#include "test_common.h" #include "token_setproc.h" using namespace testing::ext; using namespace OHOS::Security::AccessToken; namespace { -static const std::string TEST_BUNDLE_NAME = "ohos"; -static const std::string TEST_PKG_NAME = "com.softbus.test"; static const std::string TEST_PERMISSION = "ohos.permission.DISTRIBUTED_DATASYNC"; static const std::string TEST_PERMISSION_NOT_REQUESTED = "ohos.permission.GRANT_SENSITIVE_PERMISSIONS"; -static const int TEST_USER_ID = 0; - +static uint64_t g_selfShellTokenId = 0; +static MockHapToken* g_mock = nullptr; PermissionStateFull g_infoManagerTestState1 = { .permissionName = TEST_PERMISSION, .isGeneral = true, @@ -50,73 +49,53 @@ HapInfoParams g_infoManagerTestInfoParms = { HapPolicyParams g_infoManagerTestPolicyPrams = { .apl = APL_NORMAL, .domain = "test.domain5", - .permList = {}, .permStateList = {g_infoManagerTestState1} }; - -void NativeTokenGet() -{ - uint64_t fullTokenId; - const char **perms = new const char *[4]; - perms[0] = "ohos.permission.DISTRIBUTED_DATASYNC"; - perms[2] = "ohos.permission.REVOKE_SENSITIVE_PERMISSIONS"; // 2 means the index. - perms[1] = "ohos.permission.GRANT_SENSITIVE_PERMISSIONS"; - perms[3] = "ohos.permission.GET_SENSITIVE_PERMISSIONS"; // 3 means the index. - - NativeTokenInfoParams infoInstance = { - .dcapsNum = 0, - .permsNum = 4, - .aclsNum = 0, - .dcaps = nullptr, - .perms = perms, - .acls = nullptr, - .aplStr = "system_core", - }; - - infoInstance.processName = "TestCase"; - fullTokenId = GetAccessTokenId(&infoInstance); - EXPECT_EQ(0, SetSelfTokenID(fullTokenId)); - AccessTokenKit::ReloadNativeTokenInfo(); - delete[] perms; -} } void SecurityComponentGrantTest::SetUpTestCase() { + g_selfShellTokenId = GetSelfTokenID(); + TestCommon::SetTestEvironment(g_selfShellTokenId); + + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.MANAGE_HAP_TOKENID"); + reqPerm.emplace_back("ohos.permission.GET_SENSITIVE_PERMISSIONS"); + reqPerm.emplace_back("ohos.permission.REVOKE_SENSITIVE_PERMISSIONS"); + reqPerm.emplace_back("ohos.permission.GRANT_SENSITIVE_PERMISSIONS"); + g_mock = new (std::nothrow) MockHapToken("SecurityComponentGrantTest", reqPerm, true); + + GTEST_LOG_(INFO) << "SecurityComponentGrantTest, tokenID is " << g_selfShellTokenId; + GTEST_LOG_(INFO) << "SecurityComponentGrantTest, sel is " << GetSelfTokenID(); // make test case clean - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenID); - - NativeTokenGet(); + AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(g_infoManagerTestInfoParms.userID, + g_infoManagerTestInfoParms.bundleName, g_infoManagerTestInfoParms.instIndex); + TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID); } void SecurityComponentGrantTest::TearDownTestCase() { + if (g_mock != nullptr) { + delete g_mock; + g_mock = nullptr; + } + TestCommon::ResetTestEvironment(); + SetSelfTokenID(g_selfShellTokenId); } void SecurityComponentGrantTest::SetUp() { - selfTokenId_ = GetSelfTokenID(); } void SecurityComponentGrantTest::TearDown() -{ - EXPECT_EQ(0, SetSelfTokenID(selfTokenId_)); -} - -void SecurityComponentGrantTest::DeleteTestToken() const { } AccessTokenID SecurityComponentGrantTest::AllocTestToken() const { AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); + EXPECT_EQ(RET_SUCCESS, + TestCommon::AllocTestHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams, tokenIdEx)); return tokenIdEx.tokenIdExStruct.tokenID; } @@ -132,24 +111,24 @@ HWTEST_F(SecurityComponentGrantTest, SecurityComponentGrantTest001, TestSize.Lev ASSERT_NE(tokenID, INVALID_TOKENID); int32_t status = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION, false); ASSERT_EQ(status, PERMISSION_DENIED); - int32_t res = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); + int32_t res = TestCommon::GrantPermissionByTest(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); ASSERT_EQ(res, RET_SUCCESS); - uint32_t flag; - res = AccessTokenKit::GetPermissionFlag(tokenID, TEST_PERMISSION, flag); + uint32_t flag = 0; + res = TestCommon::GetPermissionFlagByTest(tokenID, TEST_PERMISSION, flag); ASSERT_EQ(res, RET_SUCCESS); ASSERT_NE(((static_cast(flag)) & PERMISSION_COMPONENT_SET), 0); status = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION, false); ASSERT_EQ(status, PERMISSION_GRANTED); - res = AccessTokenKit::RevokePermission(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); + res = TestCommon::RevokePermissionByTest(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); ASSERT_EQ(res, RET_SUCCESS); status = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION, false); ASSERT_EQ(status, PERMISSION_DENIED); - res = AccessTokenKit::GetPermissionFlag(tokenID, TEST_PERMISSION, flag); + res = TestCommon::GetPermissionFlagByTest(tokenID, TEST_PERMISSION, flag); ASSERT_EQ(res, RET_SUCCESS); ASSERT_EQ(((static_cast(flag)) & PERMISSION_COMPONENT_SET), 0); - res = AccessTokenKit::DeleteToken(tokenID); + res = TestCommon::DeleteTestHapToken(tokenID); ASSERT_EQ(res, RET_SUCCESS); } @@ -165,28 +144,28 @@ HWTEST_F(SecurityComponentGrantTest, SecurityComponentGrantTest002, TestSize.Lev ASSERT_NE(tokenID, INVALID_TOKENID); // user grant - int32_t res = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION, PERMISSION_USER_FIXED); + int32_t res = TestCommon::GrantPermissionByTest(tokenID, TEST_PERMISSION, PERMISSION_USER_FIXED); ASSERT_EQ(res, RET_SUCCESS); // security component grant - res = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); + res = TestCommon::GrantPermissionByTest(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); ASSERT_EQ(res, RET_SUCCESS); int32_t status = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION, false); ASSERT_EQ(status, PERMISSION_GRANTED); - uint32_t flag; - res = AccessTokenKit::GetPermissionFlag(tokenID, TEST_PERMISSION, flag); + uint32_t flag = 0; + res = TestCommon::GetPermissionFlagByTest(tokenID, TEST_PERMISSION, flag); ASSERT_EQ(res, RET_SUCCESS); ASSERT_EQ(((static_cast(flag)) & PERMISSION_COMPONENT_SET), 0); // security component revoke - res = AccessTokenKit::RevokePermission(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); + res = TestCommon::RevokePermissionByTest(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); ASSERT_EQ(res, RET_SUCCESS); status = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION, false); ASSERT_EQ(status, PERMISSION_GRANTED); - res = AccessTokenKit::GetPermissionFlag(tokenID, TEST_PERMISSION, flag); + res = TestCommon::GetPermissionFlagByTest(tokenID, TEST_PERMISSION, flag); ASSERT_EQ(res, RET_SUCCESS); ASSERT_EQ(((static_cast(flag)) & PERMISSION_COMPONENT_SET), 0); - res = AccessTokenKit::DeleteToken(tokenID); + res = TestCommon::DeleteTestHapToken(tokenID); ASSERT_EQ(res, RET_SUCCESS); } @@ -202,28 +181,28 @@ HWTEST_F(SecurityComponentGrantTest, SecurityComponentGrantTest003, TestSize.Lev ASSERT_NE(tokenID, INVALID_TOKENID); // system grant - int32_t res = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION, PERMISSION_GRANTED_BY_POLICY); + int32_t res = TestCommon::GrantPermissionByTest(tokenID, TEST_PERMISSION, PERMISSION_GRANTED_BY_POLICY); ASSERT_EQ(res, RET_SUCCESS); // security component grant - res = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); + res = TestCommon::GrantPermissionByTest(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); ASSERT_EQ(res, RET_SUCCESS); int32_t status = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION, false); ASSERT_EQ(status, PERMISSION_GRANTED); - uint32_t flag; - AccessTokenKit::GetPermissionFlag(tokenID, TEST_PERMISSION, flag); + uint32_t flag = 0; + TestCommon::GetPermissionFlagByTest(tokenID, TEST_PERMISSION, flag); ASSERT_EQ(((static_cast(flag)) & PERMISSION_COMPONENT_SET), 0); // security component revoke - res = AccessTokenKit::RevokePermission(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); + res = TestCommon::RevokePermissionByTest(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); ASSERT_EQ(res, RET_SUCCESS); status = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION, false); ASSERT_EQ(status, PERMISSION_GRANTED); - res = AccessTokenKit::GetPermissionFlag(tokenID, TEST_PERMISSION, flag); + res = TestCommon::GetPermissionFlagByTest(tokenID, TEST_PERMISSION, flag); ASSERT_EQ(res, RET_SUCCESS); ASSERT_EQ(((static_cast(flag)) & PERMISSION_COMPONENT_SET), 0); - res = AccessTokenKit::DeleteToken(tokenID); + res = TestCommon::DeleteTestHapToken(tokenID); ASSERT_EQ(res, RET_SUCCESS); } @@ -239,28 +218,28 @@ HWTEST_F(SecurityComponentGrantTest, SecurityComponentGrantTest004, TestSize.Lev ASSERT_NE(tokenID, INVALID_TOKENID); // user revoke - int32_t res = AccessTokenKit::RevokePermission(tokenID, TEST_PERMISSION, PERMISSION_USER_FIXED); + int32_t res = TestCommon::RevokePermissionByTest(tokenID, TEST_PERMISSION, PERMISSION_USER_FIXED); ASSERT_EQ(res, RET_SUCCESS); // security component grant - res = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); + res = TestCommon::GrantPermissionByTest(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); ASSERT_NE(res, RET_SUCCESS); int32_t status = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION, false); ASSERT_EQ(status, PERMISSION_DENIED); - uint32_t flag; - res = AccessTokenKit::GetPermissionFlag(tokenID, TEST_PERMISSION, flag); + uint32_t flag = 0; + res = TestCommon::GetPermissionFlagByTest(tokenID, TEST_PERMISSION, flag); ASSERT_EQ(res, RET_SUCCESS); ASSERT_EQ(((static_cast(flag)) & PERMISSION_COMPONENT_SET), 0); // security component revoke - res = AccessTokenKit::RevokePermission(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); + res = TestCommon::RevokePermissionByTest(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); ASSERT_EQ(res, RET_SUCCESS); status = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION, false); ASSERT_EQ(status, PERMISSION_DENIED); - AccessTokenKit::GetPermissionFlag(tokenID, TEST_PERMISSION, flag); + TestCommon::GetPermissionFlagByTest(tokenID, TEST_PERMISSION, flag); ASSERT_EQ(((static_cast(flag)) & PERMISSION_COMPONENT_SET), 0); - res = AccessTokenKit::DeleteToken(tokenID); + res = TestCommon::DeleteTestHapToken(tokenID); ASSERT_EQ(res, RET_SUCCESS); } @@ -276,28 +255,28 @@ HWTEST_F(SecurityComponentGrantTest, SecurityComponentGrantTest005, TestSize.Lev ASSERT_NE(tokenID, INVALID_TOKENID); // security component grant - int32_t res = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); + int32_t res = TestCommon::GrantPermissionByTest(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); ASSERT_EQ(res, RET_SUCCESS); int32_t status = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION, false); ASSERT_EQ(status, PERMISSION_GRANTED); // user grant - uint32_t flag; - res = AccessTokenKit::GetPermissionFlag(tokenID, TEST_PERMISSION, flag); + uint32_t flag = 0; + res = TestCommon::GetPermissionFlagByTest(tokenID, TEST_PERMISSION, flag); ASSERT_EQ(res, RET_SUCCESS); ASSERT_NE(((static_cast(flag)) & PERMISSION_COMPONENT_SET), 0); - res = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION, PERMISSION_USER_FIXED); + res = TestCommon::GrantPermissionByTest(tokenID, TEST_PERMISSION, PERMISSION_USER_FIXED); ASSERT_EQ(res, RET_SUCCESS); - AccessTokenKit::GetPermissionFlag(tokenID, TEST_PERMISSION, flag); + TestCommon::GetPermissionFlagByTest(tokenID, TEST_PERMISSION, flag); ASSERT_EQ(((static_cast(flag)) & PERMISSION_COMPONENT_SET), 0); // security component revoke - res = AccessTokenKit::RevokePermission(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); + res = TestCommon::RevokePermissionByTest(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); ASSERT_EQ(res, RET_SUCCESS); status = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION, false); ASSERT_EQ(status, PERMISSION_GRANTED); - res = AccessTokenKit::DeleteToken(tokenID); + res = TestCommon::DeleteTestHapToken(tokenID); ASSERT_EQ(res, RET_SUCCESS); } @@ -313,31 +292,31 @@ HWTEST_F(SecurityComponentGrantTest, SecurityComponentGrantTest006, TestSize.Lev ASSERT_NE(tokenID, INVALID_TOKENID); // security component grant - int32_t res = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); + int32_t res = TestCommon::GrantPermissionByTest(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); ASSERT_EQ(res, RET_SUCCESS); int32_t status = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION, false); ASSERT_EQ(status, PERMISSION_GRANTED); - uint32_t flag; - res = AccessTokenKit::GetPermissionFlag(tokenID, TEST_PERMISSION, flag); + uint32_t flag = 0; + res = TestCommon::GetPermissionFlagByTest(tokenID, TEST_PERMISSION, flag); ASSERT_EQ(res, RET_SUCCESS); ASSERT_NE(((static_cast(flag)) & PERMISSION_COMPONENT_SET), 0); // user revoke - res = AccessTokenKit::RevokePermission(tokenID, TEST_PERMISSION, PERMISSION_USER_FIXED); + res = TestCommon::RevokePermissionByTest(tokenID, TEST_PERMISSION, PERMISSION_USER_FIXED); ASSERT_EQ(res, RET_SUCCESS); status = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION, false); ASSERT_EQ(status, PERMISSION_DENIED); - AccessTokenKit::GetPermissionFlag(tokenID, TEST_PERMISSION, flag); + TestCommon::GetPermissionFlagByTest(tokenID, TEST_PERMISSION, flag); ASSERT_EQ(((static_cast(flag)) & PERMISSION_COMPONENT_SET), 0); // security component revoke - res = AccessTokenKit::RevokePermission(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); + res = TestCommon::RevokePermissionByTest(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); ASSERT_EQ(res, RET_SUCCESS); status = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION, false); ASSERT_EQ(status, PERMISSION_DENIED); - res = AccessTokenKit::DeleteToken(tokenID); + res = TestCommon::DeleteTestHapToken(tokenID); ASSERT_EQ(res, RET_SUCCESS); } @@ -349,11 +328,13 @@ HWTEST_F(SecurityComponentGrantTest, SecurityComponentGrantTest006, TestSize.Lev */ HWTEST_F(SecurityComponentGrantTest, SecurityComponentGrantTest007, TestSize.Level1) { + uint64_t selfToken = GetSelfTokenID(); + MockNativeToken mock("foundation"); AccessTokenID tokenID = AllocTestToken(); ASSERT_NE(tokenID, INVALID_TOKENID); AccessTokenID nativeTokenID = GetSelfTokenID(); // security component grant - int32_t res = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); + int32_t res = TestCommon::GrantPermissionByTest(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); ASSERT_EQ(res, RET_SUCCESS); int32_t status = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION, false); ASSERT_EQ(status, PERMISSION_GRANTED); @@ -373,7 +354,7 @@ HWTEST_F(SecurityComponentGrantTest, SecurityComponentGrantTest007, TestSize.Lev // check not to pop up EXPECT_EQ(0, SetSelfTokenID(nativeTokenID)); - AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION, PERMISSION_USER_FIXED); + TestCommon::GrantPermissionByTest(tokenID, TEST_PERMISSION, PERMISSION_USER_FIXED); EXPECT_EQ(0, SetSelfTokenID(tokenID)); result = AccessTokenKit::GetSelfPermissionsState(permList, info); @@ -381,10 +362,13 @@ HWTEST_F(SecurityComponentGrantTest, SecurityComponentGrantTest007, TestSize.Lev // security component revoke EXPECT_EQ(0, SetSelfTokenID(nativeTokenID)); - AccessTokenKit::RevokePermission(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); + TestCommon::RevokePermissionByTest(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); - res = AccessTokenKit::DeleteToken(tokenID); + res = TestCommon::DeleteTestHapToken(tokenID); ASSERT_EQ(res, RET_SUCCESS); + + EXPECT_EQ(0, SetSelfTokenID(nativeTokenID)); + EXPECT_EQ(0, SetSelfTokenID(selfToken)); } /** @@ -399,24 +383,24 @@ HWTEST_F(SecurityComponentGrantTest, SecurityComponentGrantTest008, TestSize.Lev ASSERT_NE(tokenID, INVALID_TOKENID); // security component grant - int32_t res = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); + int32_t res = TestCommon::GrantPermissionByTest(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); ASSERT_EQ(res, RET_SUCCESS); int32_t status = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION, false); ASSERT_EQ(status, PERMISSION_GRANTED); // security component grant repeat - res = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); + res = TestCommon::GrantPermissionByTest(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); ASSERT_EQ(res, RET_SUCCESS); // security component revoke - res = AccessTokenKit::RevokePermission(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); + res = TestCommon::RevokePermissionByTest(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); ASSERT_EQ(res, RET_SUCCESS); // security component revoke repeat - res = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); + res = TestCommon::GrantPermissionByTest(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); ASSERT_EQ(res, RET_SUCCESS); - res = AccessTokenKit::DeleteToken(tokenID); + res = TestCommon::DeleteTestHapToken(tokenID); ASSERT_EQ(res, RET_SUCCESS); } @@ -459,27 +443,27 @@ HWTEST_F(SecurityComponentGrantTest, SecurityComponentGrantTest009, TestSize.Lev ASSERT_NE(tokenID, INVALID_TOKENID); // security component grant - res = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); + res = TestCommon::GrantPermissionByTest(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); ASSERT_EQ(res, RET_SUCCESS); usleep(500000); // 500000us = 0.5s ASSERT_EQ(callbackPtr->ready2_, true); callbackPtr->ready2_ = false; // user grant - res = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION, PERMISSION_USER_FIXED); + res = TestCommon::GrantPermissionByTest(tokenID, TEST_PERMISSION, PERMISSION_USER_FIXED); ASSERT_EQ(res, RET_SUCCESS); usleep(500000); // 500000us = 0.5s ASSERT_EQ(callbackPtr->ready2_, false); // security component revoke - res = AccessTokenKit::RevokePermission(tokenID, TEST_PERMISSION, PERMISSION_USER_FIXED); + res = TestCommon::RevokePermissionByTest(tokenID, TEST_PERMISSION, PERMISSION_USER_FIXED); ASSERT_EQ(res, RET_SUCCESS); usleep(500000); // 500000us = 0.5s ASSERT_EQ(callbackPtr->ready2_, true); callbackPtr->ready2_ = false; // security component revoke repeat - res = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); + res = TestCommon::GrantPermissionByTest(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); ASSERT_NE(res, RET_SUCCESS); usleep(500000); // 500000us = 0.5s ASSERT_EQ(callbackPtr->ready2_, false); @@ -487,7 +471,7 @@ HWTEST_F(SecurityComponentGrantTest, SecurityComponentGrantTest009, TestSize.Lev res = AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr); ASSERT_EQ(RET_SUCCESS, res); - res = AccessTokenKit::DeleteToken(tokenID); + res = TestCommon::DeleteTestHapToken(tokenID); ASSERT_EQ(res, RET_SUCCESS); } @@ -512,21 +496,21 @@ HWTEST_F(SecurityComponentGrantTest, SecurityComponentGrantTest010, TestSize.Lev ASSERT_NE(tokenID, INVALID_TOKENID); // security component grant - res = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); + res = TestCommon::GrantPermissionByTest(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); ASSERT_EQ(res, RET_SUCCESS); usleep(500000); // 500000us = 0.5s ASSERT_EQ(callbackPtr->ready2_, true); callbackPtr->ready2_ = false; // user revoke - res = AccessTokenKit::RevokePermission(tokenID, TEST_PERMISSION, PERMISSION_USER_FIXED); + res = TestCommon::RevokePermissionByTest(tokenID, TEST_PERMISSION, PERMISSION_USER_FIXED); ASSERT_EQ(res, RET_SUCCESS); usleep(500000); // 500000us = 0.5s ASSERT_EQ(callbackPtr->ready2_, true); callbackPtr->ready2_ = false; // security component revoke - res = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); + res = TestCommon::GrantPermissionByTest(tokenID, TEST_PERMISSION, PERMISSION_COMPONENT_SET); ASSERT_NE(res, RET_SUCCESS); usleep(500000); // 500000us = 0.5s ASSERT_EQ(callbackPtr->ready2_, false); @@ -534,7 +518,7 @@ HWTEST_F(SecurityComponentGrantTest, SecurityComponentGrantTest010, TestSize.Lev res = AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr); ASSERT_EQ(RET_SUCCESS, res); - res = AccessTokenKit::DeleteToken(tokenID); + res = TestCommon::DeleteTestHapToken(tokenID); ASSERT_EQ(res, RET_SUCCESS); } @@ -559,7 +543,7 @@ HWTEST_F(SecurityComponentGrantTest, SecurityComponentGrantTest011, TestSize.Lev ASSERT_NE(tokenID, INVALID_TOKENID); // security component grant a not requested permission - res = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION_NOT_REQUESTED, PERMISSION_COMPONENT_SET); + res = TestCommon::GrantPermissionByTest(tokenID, TEST_PERMISSION_NOT_REQUESTED, PERMISSION_COMPONENT_SET); ASSERT_EQ(res, RET_SUCCESS); usleep(500000); // 500000us = 0.5s ASSERT_EQ(callbackPtr->ready2_, true); @@ -569,7 +553,7 @@ HWTEST_F(SecurityComponentGrantTest, SecurityComponentGrantTest011, TestSize.Lev ASSERT_EQ(status, PERMISSION_GRANTED); // security component revoke - res = AccessTokenKit::RevokePermission(tokenID, TEST_PERMISSION_NOT_REQUESTED, PERMISSION_COMPONENT_SET); + res = TestCommon::RevokePermissionByTest(tokenID, TEST_PERMISSION_NOT_REQUESTED, PERMISSION_COMPONENT_SET); ASSERT_EQ(res, RET_SUCCESS); usleep(500000); // 500000us = 0.5s ASSERT_EQ(callbackPtr->ready2_, true); @@ -580,6 +564,6 @@ HWTEST_F(SecurityComponentGrantTest, SecurityComponentGrantTest011, TestSize.Lev res = AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr); ASSERT_EQ(RET_SUCCESS, res); - res = AccessTokenKit::DeleteToken(tokenID); + res = TestCommon::DeleteTestHapToken(tokenID); ASSERT_EQ(res, RET_SUCCESS); } diff --git a/interfaces/innerkits/accesstoken/test/unittest/src/security_component_grant_test.h b/interfaces/innerkits/accesstoken/test/unittest/SecurityComponentTest/security_component_grant_test.h similarity index 98% rename from interfaces/innerkits/accesstoken/test/unittest/src/security_component_grant_test.h rename to interfaces/innerkits/accesstoken/test/unittest/SecurityComponentTest/security_component_grant_test.h index a3111b54834613a9e403e4d72a886f06b04eac32..9df075cdaeb15e6dd7ddc54915f20bf78b856883 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/src/security_component_grant_test.h +++ b/interfaces/innerkits/accesstoken/test/unittest/SecurityComponentTest/security_component_grant_test.h @@ -36,7 +36,6 @@ public: unsigned int GetAccessTokenID(int userID, std::string bundleName, int instIndex); void DeleteTestToken() const; AccessTokenID AllocTestToken() const; - uint64_t selfTokenId_; std::string udid_; std::string networkId_; }; diff --git a/interfaces/innerkits/accesstoken/test/unittest/accesstoken_mock_test/accesstoken_kit_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/accesstoken_mock_test/accesstoken_kit_test.cpp deleted file mode 100644 index 1cd0cfe88104d49ecbaa2ccd94e7be6aba742ea3..0000000000000000000000000000000000000000 --- a/interfaces/innerkits/accesstoken/test/unittest/accesstoken_mock_test/accesstoken_kit_test.cpp +++ /dev/null @@ -1,616 +0,0 @@ -/* - * Copyright (c) 2021-2024 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 "accesstoken_kit_test.h" -#include -#include "access_token_error.h" -#include "permission_grant_info.h" - -using namespace testing::ext; - -namespace OHOS { -namespace Security { -namespace AccessToken { -namespace { -static constexpr int32_t DEFAULT_API_VERSION = 8; -HapInfoParams g_infoManagerTestInfoParms = { - .userID = 1, - .bundleName = "accesstoken_test", - .instIndex = 0, - .appIDDesc = "test1", - .apiVersion = DEFAULT_API_VERSION -}; -HapPolicyParams g_infoManagerTestPolicyPrams = { - .apl = APL_NORMAL, - .domain = "test.domain", -}; -#ifdef TOKEN_SYNC_ENABLE -static const int32_t FAKE_SYNC_RET = 0xabcdef; -class TokenSyncCallbackImpl : public TokenSyncKitInterface { - int32_t GetRemoteHapTokenInfo(const std::string& deviceID, AccessTokenID tokenID) const override - { - return FAKE_SYNC_RET; - }; - - int32_t DeleteRemoteHapTokenInfo(AccessTokenID tokenID) const override - { - return FAKE_SYNC_RET; - }; - - int32_t UpdateRemoteHapTokenInfo(const HapTokenInfoForSync& tokenInfo) const override - { - return FAKE_SYNC_RET; - }; -}; -#endif -} -void AccessTokenKitTest::SetUpTestCase() -{ -} - -void AccessTokenKitTest::TearDownTestCase() -{ -} - -void AccessTokenKitTest::SetUp() -{ -} - -void AccessTokenKitTest::TearDown() -{ -} - -/** - * @tc.name: InitHapToken001 - * @tc.desc: InitHapToken with proxy is null - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, InitHapToken001, TestSize.Level1) -{ - AccessTokenIDEx tokenIdEx = {0}; - int32_t ret = AccessTokenKit::InitHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams, tokenIdEx); - ASSERT_EQ(ret, AccessTokenError::ERR_SERVICE_ABNORMAL); -} - -/** - * @tc.name: AllocHapToken001 - * @tc.desc: AllocHapToken with proxy is null - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, AllocHapToken001, TestSize.Level1) -{ - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_EQ(INVALID_TOKENID, tokenIdEx.tokenIdExStruct.tokenID); -} - -/** - * @tc.name: AllocLocalTokenID001 - * @tc.desc: AllocLocalTokenID with proxy is null - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, AllocLocalTokenID001, TestSize.Level1) -{ - std::string remoteDevice = "remote device"; - AccessTokenID tokenId = 123; - AccessTokenID localTokenId = AccessTokenKit::AllocLocalTokenID(remoteDevice, tokenId); - ASSERT_EQ(INVALID_TOKENID, localTokenId); -} - -/** - * @tc.name: UpdateHapToken001 - * @tc.desc: UpdateHapToken with proxy is null - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, UpdateHapToken001, TestSize.Level1) -{ - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx.tokenIdExStruct.tokenID = 123; - UpdateHapInfoParams info; - info.appIDDesc = "appId desc"; - info.apiVersion = 9; - info.isSystemApp = false; - ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, - AccessTokenKit::UpdateHapToken(tokenIdEx, info, g_infoManagerTestPolicyPrams)); -} - -/** - * @tc.name: DeleteToken001 - * @tc.desc: DeleteToken with proxy is null - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, DeleteToken001, TestSize.Level1) -{ - AccessTokenID tokenId = 123; - ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::DeleteToken(tokenId)); -} - -/** - * @tc.name: GetTokenType001 - * @tc.desc: GetTokenType with proxy is null - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, GetTokenType001, TestSize.Level1) -{ - AccessTokenID tokenId = 123; - ASSERT_EQ(TOKEN_INVALID, AccessTokenKit::GetTokenType(tokenId)); -} - -/** - * @tc.name: GetHapTokenID001 - * @tc.desc: GetHapTokenID with proxy is null - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, GetHapTokenID001, TestSize.Level1) -{ - int32_t userID = 0; - std::string bundleName = "test"; - int32_t instIndex = 0; - AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(userID, bundleName, instIndex); - ASSERT_EQ(INVALID_TOKENID, tokenId); -} - -/** - * @tc.name: GetHapTokenID001 - * @tc.desc: GetHapTokenIDEx with proxy is null - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, GetHapTokenIDEx001, TestSize.Level1) -{ - int32_t userID = 0; - std::string bundleName = "test"; - int32_t instIndex = 0; - AccessTokenIDEx tokenIdEx = AccessTokenKit::GetHapTokenIDEx(userID, bundleName, instIndex); - ASSERT_EQ(INVALID_TOKENID, tokenIdEx.tokenIdExStruct.tokenID); -} - -/** - * @tc.name: GetHapTokenInfo001 - * @tc.desc: GetHapTokenInfo with proxy is null - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, GetHapTokenInfo001, TestSize.Level1) -{ - AccessTokenID tokenId = 123; - HapTokenInfo tokenInfo; - ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::GetHapTokenInfo(tokenId, tokenInfo)); -} - -/** - * @tc.name: GetNativeTokenInfo001 - * @tc.desc: GetNativeTokenInfo with proxy is null - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, GetNativeTokenInfo001, TestSize.Level1) -{ - AccessTokenID tokenId = 805920561; //805920561 is a native tokenId. - NativeTokenInfo tokenInfo; - ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::GetNativeTokenInfo(tokenId, tokenInfo)); -} - -/** - * @tc.name: VerifyAccessToken001 - * @tc.desc: VerifyAccessToken with proxy is null - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, VerifyAccessToken001, TestSize.Level1) -{ - AccessTokenID tokenId = 123; - std::string permission = "ohos.permission.CAMERA"; - ASSERT_EQ(PERMISSION_DENIED, AccessTokenKit::VerifyAccessToken(tokenId, permission)); - ASSERT_EQ(PERMISSION_DENIED, AccessTokenKit::VerifyAccessToken(tokenId, permission, true)); -} - -/** - * @tc.name: VerifyAccessToken002 - * @tc.desc: VerifyAccessToken with proxy is null - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, VerifyAccessToken002, TestSize.Level1) -{ - AccessTokenID callerTokenID = 123; - AccessTokenID firstTokenID = 456; - std::string permission = "ohos.permission.CAMERA"; - ASSERT_EQ(PERMISSION_DENIED, AccessTokenKit::VerifyAccessToken(callerTokenID, firstTokenID, permission)); - ASSERT_EQ(PERMISSION_DENIED, AccessTokenKit::VerifyAccessToken(callerTokenID, firstTokenID, permission, true)); -} - -/** - * @tc.name: VerifyAccessTokenWithList001 - * @tc.desc: VerifyAccessTokenWithList with proxy is null - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, VerifyAccessTokenWithList001, TestSize.Level1) -{ - AccessTokenID tokenId = 123; - std::vector permissionList = {"ohos.permission.CAMERA"}; - std::vector permStateList; - ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, - AccessTokenKit::VerifyAccessToken(tokenId, permissionList, permStateList, true)); - - permStateList.clear(); - ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, - AccessTokenKit::VerifyAccessToken(tokenId, permissionList, permStateList, false)); -} - -/** - * @tc.name: GetDefPermission001 - * @tc.desc: GetDefPermission with proxy is null - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, GetDefPermission001, TestSize.Level1) -{ - std::string permission = "ohos.permission.CAMERA"; - PermissionDef def; - ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::GetDefPermission(permission, def)); -} - -/** - * @tc.name: GetReqPermissions001 - * @tc.desc: GetReqPermissions with proxy is null - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, GetReqPermissions001, TestSize.Level1) -{ - AccessTokenID tokenId = 123; - std::vector permList; - ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::GetReqPermissions(tokenId, permList, false)); -} - -/** - * @tc.name: GetTokenIDByUserID001 - * @tc.desc: GetTokenIDByUserID with proxy is null - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, GetTokenIDByUserID001, TestSize.Level1) -{ - int32_t userID = 1; - std::unordered_set tokenIdList; - ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::GetTokenIDByUserID(userID, tokenIdList)); -} - -/** - * @tc.name: GetPermissionFlag001 - * @tc.desc: GetPermissionFlag with proxy is null - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, GetPermissionFlag001, TestSize.Level1) -{ - AccessTokenID tokenId = 123; - std::string permission = "ohos.permission.CAMERA"; - uint32_t flag; - ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::GetPermissionFlag(tokenId, permission, flag)); -} - -/** - * @tc.name: SetPermissionRequestToggleStatus001 - * @tc.desc: SetPermissionRequestToggleStatus with proxy is null - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, SetPermissionRequestToggleStatus001, TestSize.Level1) -{ - int32_t userID = 123; - std::string permission = "ohos.permission.CAMERA"; - uint32_t status = PermissionRequestToggleStatus::CLOSED; - ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::SetPermissionRequestToggleStatus(permission, - status, userID)); -} - -/** - * @tc.name: GetPermissionRequestToggleStatus001 - * @tc.desc: GetPermissionRequestToggleStatus with proxy is null - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, GetPermissionRequestToggleStatus001, TestSize.Level1) -{ - int32_t userID = 123; - std::string permission = "ohos.permission.CAMERA"; - uint32_t status; - ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::GetPermissionRequestToggleStatus(permission, - status, userID)); -} - -/** - * @tc.name: GetSelfPermissionsState001 - * @tc.desc: GetSelfPermissionsState with proxy is null - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, GetSelfPermissionsState001, TestSize.Level1) -{ - std::vector permList; - PermissionGrantInfo info; - ASSERT_EQ(INVALID_OPER, AccessTokenKit::GetSelfPermissionsState(permList, info)); -} - -/** - * @tc.name: GetPermissionsStatus001 - * @tc.desc: GetPermissionsStatus with proxy is null - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, GetPermissionsStatus001, TestSize.Level1) -{ - AccessTokenID tokenId = 123; - std::vector permsList; - PermissionListState perm = { - .permissionName = "ohos.permission.testPermDef1", - .state = SETTING_OPER - }; - permsList.emplace_back(perm); - ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, - AccessTokenKit::GetPermissionsStatus(tokenId, permsList)); -} - -/** - * @tc.name: GrantPermission001 - * @tc.desc: GrantPermission with proxy is null - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, GrantPermission001, TestSize.Level1) -{ - AccessTokenID tokenId = 123; - std::string permission = "ohos.permission.CAMERA"; - ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, - AccessTokenKit::GrantPermission(tokenId, permission, PERMISSION_USER_FIXED)); -} - -/** - * @tc.name: RevokePermission001 - * @tc.desc: RevokePermission with proxy is null - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, RevokePermission001, TestSize.Level1) -{ - AccessTokenID tokenId = 123; - std::string permission = "ohos.permission.CAMERA"; - ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, - AccessTokenKit::RevokePermission(tokenId, permission, PERMISSION_USER_FIXED)); -} - -/** - * @tc.name: ClearUserGrantedPermissionState001 - * @tc.desc: ClearUserGrantedPermissionState with proxy is null - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, ClearUserGrantedPermissionState001, TestSize.Level1) -{ - AccessTokenID tokenId = 123; - ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::ClearUserGrantedPermissionState(tokenId)); -} - -class CbCustomizeTest : public PermStateChangeCallbackCustomize { -public: - explicit CbCustomizeTest(const PermStateChangeScope &scopeInfo) - : PermStateChangeCallbackCustomize(scopeInfo) - { - } - ~CbCustomizeTest() {} - - virtual void PermStateChangeCallback(PermStateChangeInfo& result) - { - } -}; - -/** - * @tc.name: RegisterPermStateChangeCallback001 - * @tc.desc: RegisterPermStateChangeCallback with proxy is null - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, RegisterPermStateChangeCallback001, TestSize.Level1) -{ - PermStateChangeScope scopeInfo; - scopeInfo.permList = {"ohos.permission.CAMERA"}; - scopeInfo.tokenIDs = {}; - auto callbackPtr = std::make_shared(scopeInfo); - ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr)); - ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr)); -} - -/** - * @tc.name: ReloadNativeTokenInfo001 - * @tc.desc: ReloadNativeTokenInfo with proxy is null - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, ReloadNativeTokenInfo001, TestSize.Level1) -{ - ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::ReloadNativeTokenInfo()); -} - -/** - * @tc.name: GetNativeTokenId001 - * @tc.desc: Verify the GetNativeTokenId abnormal branch return nullptr proxy. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, GetNativeTokenId001, TestSize.Level1) -{ - std::string processName = "hdcd"; - AccessTokenID tokenID = AccessTokenKit::GetNativeTokenId(processName); - ASSERT_EQ(INVALID_TOKENID, tokenID); -} - -#ifdef TOKEN_SYNC_ENABLE -/** - * @tc.name: GetHapTokenInfoFromRemote001 - * @tc.desc: GetHapTokenInfoFromRemote with proxy is null - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, GetHapTokenInfoFromRemote001, TestSize.Level1) -{ - AccessTokenID tokenId = 123; - HapTokenInfoForSync hapSync; - ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::GetHapTokenInfoFromRemote(tokenId, hapSync)); -} - -/** - * @tc.name: SetRemoteHapTokenInfo001 - * @tc.desc: SetRemoteHapTokenInfo with proxy is null - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, SetRemoteHapTokenInfo001, TestSize.Level1) -{ - std::string device = "device"; - HapTokenInfoForSync hapSync; - ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::SetRemoteHapTokenInfo(device, hapSync)); -} - -/** - * @tc.name: DeleteRemoteToken001 - * @tc.desc: DeleteRemoteToken with proxy is null - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, DeleteRemoteToken001, TestSize.Level1) -{ - std::string device = "device"; - AccessTokenID tokenId = 123; - ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::DeleteRemoteToken(device, tokenId)); -} - -/** - * @tc.name: GetRemoteNativeTokenID001 - * @tc.desc: GetRemoteNativeTokenID with proxy is null - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, GetRemoteNativeTokenID001, TestSize.Level1) -{ - std::string device = "device"; - AccessTokenID tokenId = 123; - ASSERT_EQ(INVALID_TOKENID, AccessTokenKit::GetRemoteNativeTokenID(device, tokenId)); -} - -/** - * @tc.name: DeleteRemoteDeviceTokens001 - * @tc.desc: DeleteRemoteDeviceTokens with proxy is null - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, DeleteRemoteDeviceTokens001, TestSize.Level1) -{ - std::string device = "device"; - ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::DeleteRemoteDeviceTokens(device)); -} - -/** - * @tc.name: RegisterTokenSyncCallback001 - * @tc.desc: RegisterTokenSyncCallback with proxy is null - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, RegisterTokenSyncCallback001, TestSize.Level1) -{ - std::shared_ptr callback = std::make_shared(); - EXPECT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::RegisterTokenSyncCallback(callback)); - EXPECT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::UnRegisterTokenSyncCallback()); -} -#endif - -/** - * @tc.name: DumpTokenInfo001 - * @tc.desc: DumpTokenInfo with proxy is null - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, DumpTokenInfo001, TestSize.Level1) -{ - std::string dumpInfo; - AtmToolsParamInfo info; - info.tokenId = 123; - AccessTokenKit::DumpTokenInfo(info, dumpInfo); - ASSERT_EQ("", dumpInfo); -} - -/** - * @tc.name: SetPermDialogCap001 - * @tc.desc: SetPermDialogCap with proxy is null - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, SetPermDialogCap001, TestSize.Level1) -{ - HapBaseInfo hapBaseInfo; - ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::SetPermDialogCap(hapBaseInfo, true)); -} - -/** - * @tc.name: GetPermissionManagerInfo001 - * @tc.desc: GetPermissionManagerInfo with proxy is null - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, GetPermissionManagerInfo001, TestSize.Level1) -{ - PermissionGrantInfo info; - AccessTokenKit::GetPermissionManagerInfo(info); - ASSERT_EQ(true, info.grantBundleName.empty()); -} - -/** - * @tc.name: GrantPermissionForSpecifiedTime001 - * @tc.desc: GrantPermissionForSpecifiedTime with proxy is null - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, GrantPermissionForSpecifiedTime001, TestSize.Level1) -{ - AccessTokenID tokenId = 123; - std::string permission = "permission"; - uint32_t onceTime = 1; - ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, - AccessTokenKit::GrantPermissionForSpecifiedTime(tokenId, permission, onceTime)); -} - -/** - * @tc.name: RequestAppPermOnSettingTest001 - * @tc.desc: RequestAppPermOnSetting with proxy is null - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, RequestAppPermOnSettingTest001, TestSize.Level1) -{ - AccessTokenID tokenId = 123; - ASSERT_EQ(AccessTokenError::ERR_SERVICE_ABNORMAL, AccessTokenKit::RequestAppPermOnSetting(tokenId)); -} -} // namespace AccessToken -} // namespace Security -} diff --git a/interfaces/innerkits/accesstoken/test/unittest/accesstoken_mock_test/accesstoken_kit_test.h b/interfaces/innerkits/accesstoken/test/unittest/accesstoken_mock_test/accesstoken_kit_test.h deleted file mode 100644 index d34dc9481b68d72a11c497efba18ca5a701635fa..0000000000000000000000000000000000000000 --- a/interfaces/innerkits/accesstoken/test/unittest/accesstoken_mock_test/accesstoken_kit_test.h +++ /dev/null @@ -1,41 +0,0 @@ -/* - * Copyright (c) 2021-2022 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 TOKENSYNC_KIT_TEST_H -#define TOKENSYNC_KIT_TEST_H - -#include - -#include "access_token.h" -#include "accesstoken_kit.h" -#include "iservice_registry.h" - -namespace OHOS { -namespace Security { -namespace AccessToken { -class AccessTokenKitTest : public testing::Test { -public: - static void SetUpTestCase(); - - static void TearDownTestCase(); - - void SetUp(); - - void TearDown(); -}; -} // namespace AccessToken -} // namespace Security -} // namespace OHOS -#endif // PRIVACY_KIT_TEST_H \ No newline at end of file diff --git a/interfaces/innerkits/accesstoken/test/unittest/common/test_common.cpp b/interfaces/innerkits/accesstoken/test/unittest/common/test_common.cpp index 9068f80db9c08e9c59b050874635bcbefbe3f322..7570865b2ff9a9ac4395ae23c4ab97cec6b0c1ee 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/common/test_common.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/common/test_common.cpp @@ -13,12 +13,16 @@ * limitations under the License. */ #include "test_common.h" -#include "gtest/gtest.h" #include +#include "atm_tools_param_info.h" +#include "gtest/gtest.h" +#include "test_common.h" namespace OHOS { namespace Security { namespace AccessToken { +std::mutex g_lockSetToken; +uint64_t g_shellTokenId = 0; HapInfoParams TestCommon::GetInfoManagerTestInfoParms() { HapInfoParams g_infoManagerTestInfoParms = { @@ -120,7 +124,6 @@ HapPolicyParams TestCommon::GetTestPolicyParams() HapPolicyParams g_testPolicyParams = { .apl = APL_SYSTEM_CORE, .domain = "test_domain", - .permList = {}, .permStateList = { g_testPermReq }, .aclRequestedList = {}, .preAuthorizationInfo = {} @@ -204,6 +207,7 @@ void TestCommon::TestPreparePermDefList(HapPolicyParams &policy) policy.permList.emplace_back(permissionDefAlpha); } + void TestCommon::TestPrepareKernelPermissionDefinition( HapInfoParams& infoParams, HapPolicyParams& policyParams) { @@ -265,12 +269,110 @@ void TestCommon::TestPrepareKernelPermissionStatus(HapPolicyParams& policyParams policyParams.aclExtendedMap["ohos.permission.CAMERA"] = "789"; // filtered } -AccessTokenID TestCommon::AllocTestToken( - const HapInfoParams& hapInfo, const HapPolicyParams& hapPolicy) +void TestCommon::SetTestEvironment(uint64_t shellTokenId) +{ + std::lock_guard lock(g_lockSetToken); + g_shellTokenId = shellTokenId; +} + +void TestCommon::ResetTestEvironment() +{ + std::lock_guard lock(g_lockSetToken); + g_shellTokenId = 0; +} + +uint64_t TestCommon::GetShellTokenId() +{ + std::lock_guard lock(g_lockSetToken); + return g_shellTokenId; +} + +int32_t TestCommon::AllocTestHapToken( + const HapInfoParams& hapInfo, HapPolicyParams& hapPolicy, AccessTokenIDEx& tokenIdEx) +{ + uint64_t selfTokenId = GetSelfTokenID(); + for (auto& permissionStateFull : hapPolicy.permStateList) { + PermissionDef permDefResult; + if (AccessTokenKit::GetDefPermission(permissionStateFull.permissionName, permDefResult) != RET_SUCCESS) { + continue; + } + if (permDefResult.availableLevel > hapPolicy.apl) { + hapPolicy.aclRequestedList.emplace_back(permissionStateFull.permissionName); + } + } + if (TestCommon::GetNativeTokenIdFromProcess("foundation") == selfTokenId) { + return AccessTokenKit::InitHapToken(hapInfo, hapPolicy, tokenIdEx); + } + + // set sh token for self + MockNativeToken mock("foundation"); + int32_t ret = AccessTokenKit::InitHapToken(hapInfo, hapPolicy, tokenIdEx); + + // restore + EXPECT_EQ(0, SetSelfTokenID(selfTokenId)); + + return ret; +} + +AccessTokenIDEx TestCommon::AllocAndGrantHapTokenByTest(const HapInfoParams& info, HapPolicyParams& policy) { + for (const auto& permissionStateFull : policy.permStateList) { + PermissionDef permDefResult; + if (AccessTokenKit::GetDefPermission(permissionStateFull.permissionName, permDefResult) != RET_SUCCESS) { + continue; + } + if (permDefResult.availableLevel > policy.apl) { + policy.aclRequestedList.emplace_back(permissionStateFull.permissionName); + } + } + AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(hapInfo, hapPolicy); - return tokenIdEx.tokenIdExStruct.tokenID; + EXPECT_EQ(RET_SUCCESS, TestCommon::AllocTestHapToken(info, policy, tokenIdEx)); + AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID; + EXPECT_NE(tokenId, INVALID_TOKENID); + + for (const auto& permissionStateFull : policy.permStateList) { + if (permissionStateFull.grantStatus[0] == PERMISSION_GRANTED) { + TestCommon::GrantPermissionByTest( + tokenId, permissionStateFull.permissionName, permissionStateFull.grantFlags[0]); + } else { + TestCommon::RevokePermissionByTest( + tokenId, permissionStateFull.permissionName, permissionStateFull.grantFlags[0]); + } + } + return tokenIdEx; +} + +int32_t TestCommon::DeleteTestHapToken(AccessTokenID tokenID) +{ + uint64_t selfTokenId = GetSelfTokenID(); + if (TestCommon::GetNativeTokenIdFromProcess("foundation") == selfTokenId) { + return AccessTokenKit::DeleteToken(tokenID); + } + + // set sh token for self + MockNativeToken mock("foundation"); + + int32_t ret = AccessTokenKit::DeleteToken(tokenID); + // restore + EXPECT_EQ(0, SetSelfTokenID(selfTokenId)); + return ret; +} + +int32_t TestCommon::GrantPermissionByTest(AccessTokenID tokenID, const std::string& permission, uint32_t flag) +{ + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.GRANT_SENSITIVE_PERMISSIONS"); + MockHapToken mock("AccessTokenTestGrant", reqPerm); + return AccessTokenKit::GrantPermission(tokenID, permission, flag); +} + +int32_t TestCommon::RevokePermissionByTest(AccessTokenID tokenID, const std::string& permission, uint32_t flag) +{ + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.REVOKE_SENSITIVE_PERMISSIONS"); + MockHapToken mock("AccessTokenTestRevoke", reqPerm); + return AccessTokenKit::RevokePermission(tokenID, permission, flag); } uint64_t TestCommon::GetNativeToken(const char *processName, const char **perms, int32_t permNum) @@ -292,31 +394,132 @@ uint64_t TestCommon::GetNativeToken(const char *processName, const char **perms, return tokenId; } -void TestCommon::GetNativeTokenTest() +AccessTokenID TestCommon::GetNativeTokenIdFromProcess(const std::string &process) { - uint64_t tokenId; - const char **perms = new const char *[4]; - perms[0] = "ohos.permission.DISTRIBUTED_DATASYNC"; - perms[1] = "ohos.permission.GRANT_SENSITIVE_PERMISSIONS"; - perms[2] = "ohos.permission.REVOKE_SENSITIVE_PERMISSIONS"; // 2 means the second permission - perms[3] = "ohos.permission.GET_SENSITIVE_PERMISSIONS"; // 3 means the third permission + uint64_t selfTokenId = GetSelfTokenID(); + EXPECT_EQ(0, SetSelfTokenID(TestCommon::GetShellTokenId())); // set shell token - NativeTokenInfoParams infoInstance = { - .dcapsNum = 0, - .permsNum = 4, - .aclsNum = 0, - .dcaps = nullptr, - .perms = perms, - .acls = nullptr, - .aplStr = "system_core", + std::string dumpInfo; + AtmToolsParamInfo info; + info.processName = process; + AccessTokenKit::DumpTokenInfo(info, dumpInfo); + size_t pos = dumpInfo.find("\"tokenID\": "); + if (pos == std::string::npos) { + return 0; + } + pos += std::string("\"tokenID\": ").length(); + std::string numStr; + while (pos < dumpInfo.length() && std::isdigit(dumpInfo[pos])) { + numStr += dumpInfo[pos]; + ++pos; + } + // restore + EXPECT_EQ(0, SetSelfTokenID(selfTokenId)); + + std::istringstream iss(numStr); + AccessTokenID tokenID; + iss >> tokenID; + return tokenID; +} + +// need call by native process +AccessTokenIDEx TestCommon::GetHapTokenIdFromBundle( + int32_t userID, const std::string& bundleName, int32_t instIndex) +{ + uint64_t selfTokenId = GetSelfTokenID(); + ATokenTypeEnum type = AccessTokenKit::GetTokenTypeFlag(static_cast(selfTokenId)); + if (type != TOKEN_NATIVE) { + AccessTokenID tokenId1 = GetNativeTokenIdFromProcess("accesstoken_service"); + EXPECT_EQ(0, SetSelfTokenID(tokenId1)); + } + AccessTokenIDEx tokenIdEx = AccessTokenKit::GetHapTokenIDEx(userID, bundleName, instIndex); + + EXPECT_EQ(0, SetSelfTokenID(selfTokenId)); + return tokenIdEx; +} + + +int32_t TestCommon::GetReqPermissionsByTest( + AccessTokenID tokenID, std::vector& permStatList, bool isSystemGrant) +{ + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.GET_SENSITIVE_PERMISSIONS"); + MockHapToken mock("GetReqPermissionsByTest", reqPerm); + return AccessTokenKit::GetReqPermissions(tokenID, permStatList, isSystemGrant); +} + +int32_t TestCommon::GetPermissionFlagByTest(AccessTokenID tokenID, const std::string& permission, uint32_t& flag) +{ + std::vector reqPerm; + reqPerm.emplace_back("ohos.permission.GET_SENSITIVE_PERMISSIONS"); + MockHapToken mock("GetPermissionFlagByTest", reqPerm, true); + return AccessTokenKit::GetPermissionFlag(tokenID, permission, flag); +} + +MockNativeToken::MockNativeToken(const std::string& process) +{ + selfToken_ = GetSelfTokenID(); + uint32_t tokenId = TestCommon::GetNativeTokenIdFromProcess(process); + // GTEST_LOG_(INFO) << "begin mock, process: " << process << ", id: " << tokenId; + SetSelfTokenID(tokenId); +} + +MockNativeToken::~MockNativeToken() +{ + // GTEST_LOG_(INFO) << "end mock, SetSelfTokenID id: " << selfToken_; + SetSelfTokenID(selfToken_); +} + +MockHapToken::MockHapToken( + const std::string& bundle, const std::vector& reqPerm, bool isSystemApp) +{ + selfToken_ = GetSelfTokenID(); + HapInfoParams infoParams = { + .userID = 0, + .bundleName = bundle, + .instIndex = 0, + .appIDDesc = "AccessTokenTestAppID", + .apiVersion = TestCommon::DEFAULT_API_VERSION, + .isSystemApp = isSystemApp, + .appDistributionType = "", }; - infoInstance.processName = "TestCase"; - tokenId = GetAccessTokenId(&infoInstance); - EXPECT_EQ(0, SetSelfTokenID(tokenId)); - AccessTokenKit::ReloadNativeTokenInfo(); - delete[] perms; + HapPolicyParams policyParams = { + .apl = APL_NORMAL, + .domain = "accesstoken_test_domain", + }; + for (size_t i = 0; i < reqPerm.size(); ++i) { + PermissionDef permDefResult; + if (AccessTokenKit::GetDefPermission(reqPerm[i], permDefResult) != RET_SUCCESS) { + continue; + } + PermissionStateFull permState = { + .permissionName = reqPerm[i], + .isGeneral = true, + .resDeviceID = {"local3"}, + .grantStatus = {PermissionState::PERMISSION_DENIED}, + .grantFlags = {PermissionFlag::PERMISSION_DEFAULT_FLAG} + }; + policyParams.permStateList.emplace_back(permState); + if (permDefResult.availableLevel > policyParams.apl) { + policyParams.aclRequestedList.emplace_back(reqPerm[i]); + } + } + + AccessTokenIDEx tokenIdEx = {0}; + EXPECT_EQ(RET_SUCCESS, TestCommon::AllocTestHapToken(infoParams, policyParams, tokenIdEx)); + mockToken_= tokenIdEx.tokenIdExStruct.tokenID; + EXPECT_NE(mockToken_, INVALID_TOKENID); + EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); +} + +MockHapToken::~MockHapToken() +{ + if (mockToken_ != INVALID_TOKENID) { + EXPECT_EQ(0, TestCommon::DeleteTestHapToken(mockToken_)); + } + EXPECT_EQ(0, SetSelfTokenID(selfToken_)); } -} // namespace SecurityComponent +} // namespace AccessToken } // namespace Security } // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/accesstoken/test/unittest/common/test_common.h b/interfaces/innerkits/accesstoken/test/unittest/common/test_common.h index a6226348521f8281ac166087ff50e044a9be421b..47f2df83b7bd6c23ecdd53effcf7c73d76b5109b 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/common/test_common.h +++ b/interfaces/innerkits/accesstoken/test/unittest/common/test_common.h @@ -26,10 +26,32 @@ namespace OHOS { namespace Security { namespace AccessToken { +class MockNativeToken { +public: + explicit MockNativeToken(const std::string& process); + ~MockNativeToken(); +private: + uint64_t selfToken_; +}; + +class MockHapToken { +public: + explicit MockHapToken( + const std::string& bundle, const std::vector& reqPerm, bool isSystemApp = true); + ~MockHapToken(); +private: + uint64_t selfToken_; + uint32_t mockToken_; +}; + class TestCommon { public: static constexpr int32_t DEFAULT_API_VERSION = 12; + static void SetTestEvironment(uint64_t shellTokenId); + static void ResetTestEvironment(); + static uint64_t GetShellTokenId(); + static void GetHapParams(HapInfoParams& infoParams, HapPolicyParams& policyParams); static void TestPreparePermStateList(HapPolicyParams &policy); static void TestPreparePermDefList(HapPolicyParams &policy); @@ -41,9 +63,21 @@ public: static HapInfoParams GetInfoManagerTestNormalInfoParms(); static HapInfoParams GetInfoManagerTestSystemInfoParms(); static HapPolicyParams GetInfoManagerTestPolicyPrams(); - static AccessTokenID AllocTestToken(const HapInfoParams& hapInfo, const HapPolicyParams& hapPolicy); + + static int32_t AllocTestHapToken(const HapInfoParams& hapInfo, + HapPolicyParams& hapPolicy, AccessTokenIDEx& tokenIdEx); + static AccessTokenIDEx AllocAndGrantHapTokenByTest(const HapInfoParams& info, HapPolicyParams& policy); + static int32_t DeleteTestHapToken(AccessTokenID tokenID); static void GetNativeTokenTest(); - static uint64_t GetNativeToken(const char *processName, const char **perms, int32_t permNum); + static uint64_t GetNativeToken(const char* processName, const char** perms, int32_t permNum); + static AccessTokenID GetNativeTokenIdFromProcess(const std::string& process); + static AccessTokenIDEx GetHapTokenIdFromBundle( + int32_t userID, const std::string& bundleName, int32_t instIndex); + static int32_t GrantPermissionByTest(AccessTokenID tokenID, const std::string& permission, uint32_t flag); + static int32_t RevokePermissionByTest(AccessTokenID tokenID, const std::string& permission, uint32_t flag); + static int32_t GetReqPermissionsByTest( + AccessTokenID tokenID, std::vector& permStatList, bool isSystemGrant); + static int32_t GetPermissionFlagByTest(AccessTokenID tokenID, const std::string& permission, uint32_t& flag); }; } // namespace AccessToken } // namespace Security diff --git a/interfaces/innerkits/accesstoken/test/unittest/src/accesstoken_deny_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/src/accesstoken_deny_test.cpp deleted file mode 100644 index 732e4ecb6034c9e79c5dcb03492cc152b97a77db..0000000000000000000000000000000000000000 --- a/interfaces/innerkits/accesstoken/test/unittest/src/accesstoken_deny_test.cpp +++ /dev/null @@ -1,486 +0,0 @@ -/* - * Copyright (c) 2022-2024 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 "accesstoken_deny_test.h" -#include "accesstoken_kit.h" -#include "access_token_error.h" -#include "token_setproc.h" -#ifdef TOKEN_SYNC_ENABLE -#include "token_sync_kit_interface.h" -#endif - -namespace OHOS { -namespace Security { -namespace AccessToken { -namespace { -static AccessTokenID g_selfTokenId = 0; -static AccessTokenIDEx g_testTokenIDEx = {0}; -static int32_t g_selfUid; - -static HapPolicyParams g_PolicyPrams = { - .apl = APL_NORMAL, - .domain = "test.domain", -}; - -static HapInfoParams g_InfoParms = { - .userID = 1, - .bundleName = "ohos.test.bundle", - .instIndex = 0, - .appIDDesc = "test.bundle", - .isSystemApp = true -}; - -#ifdef TOKEN_SYNC_ENABLE -static const int32_t FAKE_SYNC_RET = 0xabcdef; -class TokenSyncCallbackImpl : public TokenSyncKitInterface { - int32_t GetRemoteHapTokenInfo(const std::string& deviceID, AccessTokenID tokenID) const override - { - return FAKE_SYNC_RET; - }; - - int32_t DeleteRemoteHapTokenInfo(AccessTokenID tokenID) const override - { - return FAKE_SYNC_RET; - }; - - int32_t UpdateRemoteHapTokenInfo(const HapTokenInfoForSync& tokenInfo) const override - { - return FAKE_SYNC_RET; - }; -}; -#endif -} -using namespace testing::ext; - -void AccessTokenDenyTest::SetUpTestCase() -{ - g_selfTokenId = GetSelfTokenID(); - g_selfUid = getuid(); -} - -void AccessTokenDenyTest::TearDownTestCase() -{ - setuid(g_selfUid); - EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId)); - GTEST_LOG_(INFO) << "PermStateChangeCallback, tokenID is " << GetSelfTokenID(); - GTEST_LOG_(INFO) << "PermStateChangeCallback, uid is " << getuid(); -} - -void AccessTokenDenyTest::SetUp() -{ - AccessTokenKit::AllocHapToken(g_InfoParms, g_PolicyPrams); - - g_testTokenIDEx = AccessTokenKit::GetHapTokenIDEx(g_InfoParms.userID, - g_InfoParms.bundleName, - g_InfoParms.instIndex); - ASSERT_NE(INVALID_TOKENID, g_testTokenIDEx.tokenIDEx); - setuid(g_selfUid); - EXPECT_EQ(0, SetSelfTokenID(g_testTokenIDEx.tokenIDEx)); - setuid(1234); // 1234: UID -} - -void AccessTokenDenyTest::TearDown() -{ - setuid(g_selfUid); - EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId)); - setuid(g_selfUid); -} - -/** - * @tc.name: InitUserPolicy001 - * @tc.desc: InitUserPolicy without authorized. - * @tc.type: FUNC - * @tc.require:Issue Number - */ -HWTEST_F(AccessTokenDenyTest, InitUserPolicy001, TestSize.Level1) -{ - UserState user = {.userId = 100, .isActive = true}; // 100 is userId - const std::vector userList = { user }; - const std::vector permList = { "ohos.permission.INTERNET" }; - int32_t ret = AccessTokenKit::InitUserPolicy(userList, permList); - EXPECT_EQ(ret, AccessTokenError::ERR_PERMISSION_DENIED); -} - - -/** - * @tc.name: UpdateUserPolicy001 - * @tc.desc: UpdateUserPolicy without authorized. - * @tc.type: FUNC - * @tc.require:Issue Number - */ -HWTEST_F(AccessTokenDenyTest, UpdateUserPolicy001, TestSize.Level1) -{ - UserState user = {.userId = 100, .isActive = true}; // 100 is userId - const std::vector userList = { user }; - int32_t ret = AccessTokenKit::UpdateUserPolicy(userList); - EXPECT_EQ(ret, AccessTokenError::ERR_PERMISSION_DENIED); -} - - -/** - * @tc.name: AllocHapToken001 - * @tc.desc: AllocHapToken with no permission - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenDenyTest, AllocHapToken001, TestSize.Level1) -{ - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_InfoParms, g_PolicyPrams); - ASSERT_EQ(INVALID_TOKENID, tokenIdEx.tokenIdExStruct.tokenID); -} - -/** - * @tc.name: InitHapToken001 - * @tc.desc: InitHapToken with no permission - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenDenyTest, InitHapToken001, TestSize.Level1) -{ - AccessTokenIDEx tokenIdEx = {0}; - int32_t ret = AccessTokenKit::InitHapToken(g_InfoParms, g_PolicyPrams, tokenIdEx); - ASSERT_NE(ret, RET_SUCCESS); -} - -/** - * @tc.name: AllocLocalTokenID001 - * @tc.desc: AllocLocalTokenID with no permission - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenDenyTest, AllocLocalTokenID001, TestSize.Level1) -{ - std::string remoteDevice = "remote device"; - AccessTokenID tokenId = 123; - AccessTokenID localTokenId = AccessTokenKit::AllocLocalTokenID(remoteDevice, tokenId); - ASSERT_EQ(INVALID_TOKENID, localTokenId); -} - -/** - * @tc.name: UpdateHapToken001 - * @tc.desc: UpdateHapToken with no permission - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenDenyTest, UpdateHapToken001, TestSize.Level1) -{ - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx.tokenIdExStruct.tokenID = 123; - UpdateHapInfoParams info; - info.appIDDesc = "appId desc"; - info.apiVersion = 9; - info.isSystemApp = false; - ASSERT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, - AccessTokenKit::UpdateHapToken(tokenIdEx, info, g_PolicyPrams)); -} - -/** - * @tc.name: DeleteToken001 - * @tc.desc: DeleteToken with no permission - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenDenyTest, DeleteToken001, TestSize.Level1) -{ - AccessTokenID tokenId = 123; - ASSERT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, AccessTokenKit::DeleteToken(tokenId)); -} - -/** - * @tc.name: GetHapTokenID001 - * @tc.desc: GetHapTokenID with no permission - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenDenyTest, GetHapTokenID001, TestSize.Level1) -{ - int32_t userID = 0; - std::string bundleName = "test"; - int32_t instIndex = 0; - AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(userID, bundleName, instIndex); - ASSERT_EQ(INVALID_TOKENID, tokenId); -} - -/** - * @tc.name: GetHapTokenInfo001 - * @tc.desc: GetHapTokenInfo with no permission - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenDenyTest, GetHapTokenInfo001, TestSize.Level1) -{ - AccessTokenID tokenId = 123; - HapTokenInfo tokenInfo; - ASSERT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, AccessTokenKit::GetHapTokenInfo(tokenId, tokenInfo)); -} - -/** - * @tc.name: GetNativeTokenInfo001 - * @tc.desc: GetNativeTokenInfo with no permission - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenDenyTest, GetNativeTokenInfo001, TestSize.Level1) -{ - AccessTokenID tokenId = 805920561; //805920561 is a native tokenId. - NativeTokenInfo tokenInfo; - ASSERT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, AccessTokenKit::GetNativeTokenInfo(tokenId, tokenInfo)); -} - -/** - * @tc.name: GetPermissionFlag001 - * @tc.desc: GetPermissionFlag with no permission - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenDenyTest, GetPermissionFlag001, TestSize.Level1) -{ - AccessTokenID tokenId = 123; - std::string permission = "ohos.permission.CAMERA"; - uint32_t flag; - ASSERT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, AccessTokenKit::GetPermissionFlag(tokenId, permission, flag)); -} - -/** - * @tc.name: SetPermissionRequestToggleStatus001 - * @tc.desc: SetPermissionRequestToggleStatus with no permission - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenDenyTest, SetPermissionRequestToggleStatus001, TestSize.Level1) -{ - int32_t userID = 123; - uint32_t status = PermissionRequestToggleStatus::CLOSED; - std::string permission = "ohos.permission.CAMERA"; - - ASSERT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, AccessTokenKit::SetPermissionRequestToggleStatus( - permission, status, userID)); -} - -/** - * @tc.name: GetPermissionRequestToggleStatus001 - * @tc.desc: GetPermissionRequestToggleStatus with no permission - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenDenyTest, GetPermissionRequestToggleStatus001, TestSize.Level1) -{ - int32_t userID = 123; - uint32_t status; - std::string permission = "ohos.permission.CAMERA"; - - ASSERT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, AccessTokenKit::GetPermissionRequestToggleStatus( - permission, status, userID)); -} - -/** - * @tc.name: GrantPermission001 - * @tc.desc: GrantPermission with no permission - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenDenyTest, GrantPermission001, TestSize.Level1) -{ - AccessTokenID tokenId = 123; - std::string permission = "ohos.permission.CAMERA"; - ASSERT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, - AccessTokenKit::GrantPermission(tokenId, permission, PERMISSION_USER_FIXED)); -} - -/** - * @tc.name: RevokePermission001 - * @tc.desc: RevokePermission with no permission - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenDenyTest, RevokePermission001, TestSize.Level1) -{ - AccessTokenID tokenId = 123; - std::string permission = "ohos.permission.CAMERA"; - ASSERT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, - AccessTokenKit::RevokePermission(tokenId, permission, PERMISSION_USER_FIXED)); -} - -/** - * @tc.name: ClearUserGrantedPermissionState001 - * @tc.desc: ClearUserGrantedPermissionState with no permission - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenDenyTest, ClearUserGrantedPermissionState001, TestSize.Level1) -{ - AccessTokenID tokenId = 123; - ASSERT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, AccessTokenKit::ClearUserGrantedPermissionState(tokenId)); -} - -class CbCustomizeTest1 : public PermStateChangeCallbackCustomize { -public: - explicit CbCustomizeTest1(const PermStateChangeScope &scopeInfo) - : PermStateChangeCallbackCustomize(scopeInfo) - { - } - ~CbCustomizeTest1() {} - - virtual void PermStateChangeCallback(PermStateChangeInfo& result) - { - } -}; - -/** - * @tc.name: RegisterPermStateChangeCallback001 - * @tc.desc: RegisterPermStateChangeCallback with no permission - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenDenyTest, RegisterPermStateChangeCallback001, TestSize.Level1) -{ - PermStateChangeScope scopeInfo; - scopeInfo.permList = {"ohos.permission.CAMERA"}; - scopeInfo.tokenIDs = {}; - auto callbackPtr = std::make_shared(scopeInfo); - ASSERT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr)); -} - -/** - * @tc.name: UnregisterPermStateChangeCallback001 - * @tc.desc: UnRegisterPermStateChangeCallback with no permission - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenDenyTest, UnregisterPermStateChangeCallback001, TestSize.Level1) -{ - setuid(g_selfUid); - - PermissionStateFull testState = { - .permissionName = "ohos.permission.GET_SENSITIVE_PERMISSIONS", - .isGeneral = true, - .resDeviceID = {"local"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {1} - }; - HapPolicyParams policyPrams = { - .apl = APL_NORMAL, - .domain = "test.domain", - .permList = {}, - .permStateList = {testState} - }; - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_InfoParms, policyPrams); - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIdExStruct.tokenID); - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); - - PermStateChangeScope scopeInfo; - scopeInfo.permList = {"ohos.permission.CAMERA"}; - scopeInfo.tokenIDs = {}; - auto callbackPtr = std::make_shared(scopeInfo); - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr)); - - EXPECT_EQ(0, SetSelfTokenID(g_testTokenIDEx.tokenIDEx)); - - ASSERT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr)); - - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr)); - - setuid(g_selfUid); - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenIdEx.tokenIdExStruct.tokenID)); -} - -/** - * @tc.name: ReloadNativeTokenInfo001 - * @tc.desc: ReloadNativeTokenInfo with no permission - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenDenyTest, ReloadNativeTokenInfo001, TestSize.Level1) -{ - ASSERT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, AccessTokenKit::ReloadNativeTokenInfo()); -} - -/** - * @tc.name: GetNativeTokenId001 - * @tc.desc: Verify the GetNativeTokenId abnormal branch return nullptr proxy. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenDenyTest, GetNativeTokenId001, TestSize.Level1) -{ - std::string processName = "hdcd"; - AccessTokenID tokenID = AccessTokenKit::GetNativeTokenId(processName); - ASSERT_EQ(INVALID_TOKENID, tokenID); -} - -/** - * @tc.name: DumpTokenInfo001 - * @tc.desc: Verify the DumpTokenInfo abnormal branch return nullptr proxy. - * @tc.type: FUNC - * @tc.require:Issue Number - */ -HWTEST_F(AccessTokenDenyTest, DumpTokenInfo001, TestSize.Level1) -{ - std::string dumpInfo; - AtmToolsParamInfo info; - info.tokenId = 123; - AccessTokenKit::DumpTokenInfo(info, dumpInfo); - ASSERT_EQ("", dumpInfo); -} - -#ifdef TOKEN_SYNC_ENABLE - -/** - * @tc.name: SetRemoteHapTokenInfo001 - * @tc.desc: SetRemoteHapTokenInfo with no permission - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenDenyTest, SetRemoteHapTokenInfo001, TestSize.Level1) -{ - std::string device = "device"; - HapTokenInfoForSync hapSync; - ASSERT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, AccessTokenKit::SetRemoteHapTokenInfo(device, hapSync)); -} - -#endif - -/** - * @tc.name: SetPermDialogCap001 - * @tc.desc: SetPermDialogCap with no permission - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenDenyTest, SetPermDialogCap001, TestSize.Level1) -{ - HapBaseInfo hapBaseInfo; - ASSERT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, AccessTokenKit::SetPermDialogCap(hapBaseInfo, true)); -} - -/** - * @tc.name: GrantPermissionForSpecifiedTime001 - * @tc.desc: GrantPermissionForSpecifiedTime with no permission - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenDenyTest, GrantPermissionForSpecifiedTime001, TestSize.Level1) -{ - AccessTokenID tokenId = 123; - std::string permission = "permission"; - uint32_t onceTime = 1; - ASSERT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, - AccessTokenKit::GrantPermissionForSpecifiedTime(tokenId, permission, onceTime)); -} -} // namespace AccessToken -} // namespace Security -} // namespace OHOS - diff --git a/interfaces/innerkits/accesstoken/test/unittest/src/accesstoken_deny_test.h b/interfaces/innerkits/accesstoken/test/unittest/src/accesstoken_deny_test.h deleted file mode 100644 index 900afdf27d0963c4ed8ab6fd2b419f181358970b..0000000000000000000000000000000000000000 --- a/interfaces/innerkits/accesstoken/test/unittest/src/accesstoken_deny_test.h +++ /dev/null @@ -1,34 +0,0 @@ -/* - * Copyright (c) 2022 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 ACCESSTOKEN_KIT_PERM_TEST_H -#define ACCESSTOKEN_KIT_PERM_TEST_H - -#include - -namespace OHOS { -namespace Security { -namespace AccessToken { -class AccessTokenDenyTest : public testing::Test { -public: - static void SetUpTestCase(); - static void TearDownTestCase(); - void SetUp(); - void TearDown(); -}; -} // namespace AccessToken -} // namespace Security -} // namespace OHOS -#endif // ACCESSTOKEN_KIT_PERM_TEST_H \ No newline at end of file diff --git a/interfaces/innerkits/accesstoken/test/unittest/src/accesstoken_kit_extension_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/src/accesstoken_kit_extension_test.cpp deleted file mode 100644 index d15891066b51da4db953b36f47fa023586519d00..0000000000000000000000000000000000000000 --- a/interfaces/innerkits/accesstoken/test/unittest/src/accesstoken_kit_extension_test.cpp +++ /dev/null @@ -1,2047 +0,0 @@ -/* - * Copyright (c) 2023 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 "accesstoken_kit_extension_test.h" -#include - -#include "access_token.h" -#include "access_token_error.h" -#include "accesstoken_common_log.h" -#include "accesstoken_service_ipc_interface_code.h" -#include "hap_token_info.h" -#include "nativetoken_kit.h" -#include "permission_grant_info.h" -#include "permission_state_change_info_parcel.h" -#include "string_ex.h" -#include "tokenid_kit.h" -#include "token_setproc.h" -#define private public -#include "accesstoken_manager_client.h" -#undef private - -using namespace testing::ext; - -namespace OHOS { -namespace Security { -namespace AccessToken { -namespace { -static constexpr int32_t DEFAULT_API_VERSION = 8; -static const std::string TEST_BUNDLE_NAME = "ohos"; -static const std::string TEST_PERMISSION_NAME_ALPHA = "ohos.permission.ALPHA"; -static const std::string TEST_PERMISSION_NAME_BETA = "ohos.permission.BETA"; -static const int TEST_USER_ID = 0; - -PermissionStateFull g_getPermissionReq = { - .permissionName = "ohos.permission.GET_SENSITIVE_PERMISSIONS", - .isGeneral = true, - .resDeviceID = {"device2"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED} -}; - -PermissionStateFull g_revokePermissionReq = { - .permissionName = "ohos.permission.REVOKE_SENSITIVE_PERMISSIONS", - .isGeneral = true, - .resDeviceID = {"device2"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED} -}; - -PermissionStateFull g_grantPermissionReq = { - .permissionName = "ohos.permission.GRANT_SENSITIVE_PERMISSIONS", - .isGeneral = true, - .resDeviceID = {"device2"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED} -}; - -PermissionDef g_infoManagerTestPermDef1 = { - .permissionName = "ohos.permission.test1", - .bundleName = "accesstoken_test", - .grantMode = 1, - .availableLevel = APL_NORMAL, - .label = "label2", - .labelId = 1, - .description = "open the door", - .descriptionId = 1 -}; - -PermissionDef g_infoManagerTestPermDef2 = { - .permissionName = "ohos.permission.test2", - .bundleName = "accesstoken_test", - .grantMode = 1, - .availableLevel = APL_NORMAL, - .label = "label2", - .labelId = 1, - .description = "break the door", - .descriptionId = 1 -}; - -PermissionDef g_infoManagerTestPermDef3 = { - .permissionName = "ohos.permission.GET_BUNDLE_INFO_TEST", - .bundleName = "accesstoken_test3", - .grantMode = 1, - .availableLevel = APL_NORMAL, - .label = "label3", - .labelId = 1, - .description = "break the door", - .descriptionId = 1 -}; - -PermissionStateFull g_infoManagerTestState1 = { - .permissionName = "ohos.permission.test1", - .isGeneral = true, - .resDeviceID = {"local2"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {1} -}; - -PermissionStateFull g_infoManagerTestState2 = { - .permissionName = "ohos.permission.test2", - .isGeneral = false, - .resDeviceID = {"device 1", "device 2"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED, PermissionState::PERMISSION_GRANTED}, - .grantFlags = {1, 2} -}; - -PermissionStateFull g_infoManagerTestState3 = { - .permissionName = "ohos.permission.GET_BUNDLE_INFO", - .isGeneral = true, - .resDeviceID = {"local3"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {1} -}; - -HapInfoParams g_infoManagerTestInfoParms = { - .userID = 1, - .bundleName = "accesstoken_test", - .instIndex = 0, - .appIDDesc = "test2", - .apiVersion = DEFAULT_API_VERSION -}; - -HapPolicyParams g_infoManagerTestPolicyPrams = { - .apl = APL_NORMAL, - .domain = "test.domain2", - .permList = {g_infoManagerTestPermDef1, g_infoManagerTestPermDef2}, - .permStateList = {g_infoManagerTestState1, g_infoManagerTestState2} -}; - -HapInfoParams g_infoManagerTestInfoParmsBak = { - .userID = 1, - .bundleName = "accesstoken_test", - .instIndex = 0, - .appIDDesc = "test2", - .apiVersion = DEFAULT_API_VERSION -}; - -HapPolicyParams g_infoManagerTestPolicyPramsBak = { - .apl = APL_NORMAL, - .domain = "test.domain2", - .permList = {g_infoManagerTestPermDef1, g_infoManagerTestPermDef2}, - .permStateList = {g_infoManagerTestState1, g_infoManagerTestState2} -}; - -HapInfoParams g_locationTestInfo = { - .userID = TEST_USER_ID, - .bundleName = "accesstoken_location_test", - .instIndex = 0, - .appIDDesc = "test2" -}; - -PermissionDef g_locationTestDefVague = { - .permissionName = "ohos.permission.APPROXIMATELY_LOCATION", - .bundleName = "accesstoken_location_test", - .grantMode = GrantMode::USER_GRANT, - .availableLevel = APL_NORMAL, - .provisionEnable = false, - .distributedSceneEnable = true -}; - -PermissionDef g_locationTestDefAccurate = { - .permissionName = "ohos.permission.LOCATION", - .bundleName = "accesstoken_location_test", - .grantMode = GrantMode::USER_GRANT, - .availableLevel = APL_NORMAL, - .provisionEnable = true, - .distributedSceneEnable = true -}; - -PermissionDef g_locationTestDefSystemGrant = { - .permissionName = "ohos.permission.locationtest1", - .bundleName = "accesstoken_location_test", - .grantMode = GrantMode::SYSTEM_GRANT, - .availableLevel = APL_NORMAL, - .provisionEnable = false, - .distributedSceneEnable = false -}; - -PermissionDef g_locationTestDefUserGrant = { - .permissionName = "ohos.permission.locationtest2", - .bundleName = "accesstoken_location_test", - .grantMode = GrantMode::USER_GRANT, - .availableLevel = APL_NORMAL, - .provisionEnable = false, - .distributedSceneEnable = false -}; - -PermissionStateFull g_locationTestStateSystemGrant = { - .permissionName = "ohos.permission.locationtest1", - .isGeneral = true, - .resDeviceID = {"device"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED} -}; - -PermissionStateFull g_locationTestStateUserGrant = { - .permissionName = "ohos.permission.locationtest2", - .isGeneral = true, - .resDeviceID = {"device"}, - .grantStatus = {PermissionState::PERMISSION_DENIED}, - .grantFlags = {PermissionFlag::PERMISSION_DEFAULT_FLAG} -}; - -PermissionStateFull g_locationTestStateVague02 = { - .permissionName = "ohos.permission.APPROXIMATELY_LOCATION", - .isGeneral = true, - .resDeviceID = {"device"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {PermissionFlag::PERMISSION_USER_FIXED} -}; - -PermissionStateFull g_locationTestStateVague10 = { - .permissionName = "ohos.permission.APPROXIMATELY_LOCATION", - .isGeneral = true, - .resDeviceID = {"device"}, - .grantStatus = {PermissionState::PERMISSION_DENIED}, - .grantFlags = {PermissionFlag::PERMISSION_DEFAULT_FLAG} -}; - -PermissionStateFull g_locationTestStateVague12 = { - .permissionName = "ohos.permission.APPROXIMATELY_LOCATION", - .isGeneral = true, - .resDeviceID = {"device"}, - .grantStatus = {PermissionState::PERMISSION_DENIED}, - .grantFlags = {PermissionFlag::PERMISSION_USER_FIXED} -}; - -PermissionStateFull g_locationTestStateAccurate02 = { - .permissionName = "ohos.permission.LOCATION", - .isGeneral = true, - .resDeviceID = {"device"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {PermissionFlag::PERMISSION_USER_FIXED} -}; - -PermissionStateFull g_locationTestStateAccurate10 = { - .permissionName = "ohos.permission.LOCATION", - .isGeneral = true, - .resDeviceID = {"device"}, - .grantStatus = {PermissionState::PERMISSION_DENIED}, - .grantFlags = {PermissionFlag::PERMISSION_DEFAULT_FLAG} -}; - -HapInfoParams g_infoManagerTestNormalInfoParms = { - .userID = 1, - .bundleName = "accesstoken_test", - .instIndex = 0, - .appIDDesc = "test2", - .apiVersion = DEFAULT_API_VERSION, - .isSystemApp = false -}; - -HapInfoParams g_infoManagerTestSystemInfoParms = { - .userID = 1, - .bundleName = "accesstoken_test", - .instIndex = 0, - .appIDDesc = "test2", - .apiVersion = DEFAULT_API_VERSION, - .isSystemApp = true -}; -uint64_t g_selfShellTokenId; -} - -void GetNativeToken() -{ - uint64_t tokenId; - const char **perms = new const char *[4]; - perms[0] = "ohos.permission.DISTRIBUTED_DATASYNC"; - perms[1] = "ohos.permission.GRANT_SENSITIVE_PERMISSIONS"; - perms[2] = "ohos.permission.REVOKE_SENSITIVE_PERMISSIONS"; // 2 means the second permission - perms[3] = "ohos.permission.GET_SENSITIVE_PERMISSIONS"; // 3 means the third permission - - NativeTokenInfoParams infoInstance = { - .dcapsNum = 0, - .permsNum = 4, - .aclsNum = 0, - .dcaps = nullptr, - .perms = perms, - .acls = nullptr, - .aplStr = "system_core", - }; - - infoInstance.processName = "TestCase"; - tokenId = GetAccessTokenId(&infoInstance); - EXPECT_EQ(0, SetSelfTokenID(tokenId)); - AccessTokenKit::ReloadNativeTokenInfo(); - delete[] perms; -} - -void AccessTokenKitExtensionTest::SetUpTestCase() -{ - g_selfShellTokenId = GetSelfTokenID(); - // clean up test cases - AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenId); - - tokenId = AccessTokenKit::GetHapTokenID(g_infoManagerTestNormalInfoParms.userID, - g_infoManagerTestNormalInfoParms.bundleName, - g_infoManagerTestNormalInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenId); - - tokenId = AccessTokenKit::GetHapTokenID(g_infoManagerTestSystemInfoParms.userID, - g_infoManagerTestSystemInfoParms.bundleName, - g_infoManagerTestSystemInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenId); - - tokenId = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenId); - - GetNativeToken(); -} - -void AccessTokenKitExtensionTest::TearDownTestCase() -{ -} - -void PreparePermStateListExt(HapPolicyParams &policy) -{ - PermissionStateFull permStatAlpha = { - .permissionName = TEST_PERMISSION_NAME_ALPHA, - .isGeneral = true, - .resDeviceID = {"device"}, - .grantStatus = {PermissionState::PERMISSION_DENIED}, - .grantFlags = {PermissionFlag::PERMISSION_USER_SET} - }; - - PermissionStateFull permStatBeta = { - .permissionName = TEST_PERMISSION_NAME_BETA, - .isGeneral = true, - .resDeviceID = {"device"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED} - }; - - PermissionStateFull permTestState5 = { - .permissionName = "ohos.permission.GET_SENSITIVE_PERMISSIONS", - .isGeneral = true, - .resDeviceID = {"local"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED} - }; - - PermissionStateFull permTestState6 = { - .permissionName = "ohos.permission.DISABLE_PERMISSION_DIALOG", - .isGeneral = true, - .resDeviceID = {"local"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED} - }; - policy.permStateList.emplace_back(permStatAlpha); - policy.permStateList.emplace_back(permStatBeta); - policy.permStateList.emplace_back(permTestState5); - policy.permStateList.emplace_back(permTestState6); -} - -void PreparePermStateList(HapPolicyParams &policy) -{ - PermissionStateFull permTestState1 = { - .permissionName = "ohos.permission.LOCATION", - .isGeneral = true, - .resDeviceID = {"local"}, - .grantStatus = {PermissionState::PERMISSION_DENIED}, - .grantFlags = {PermissionFlag::PERMISSION_DEFAULT_FLAG}, - }; - - PermissionStateFull permTestState2 = { - .permissionName = "ohos.permission.MICROPHONE", - .isGeneral = true, - .resDeviceID = {"local"}, - .grantStatus = {PermissionState::PERMISSION_DENIED}, - .grantFlags = {PermissionFlag::PERMISSION_USER_SET} - }; - - PermissionStateFull permTestState3 = { - .permissionName = "ohos.permission.WRITE_CALENDAR", - .isGeneral = true, - .resDeviceID = {"local"}, - .grantStatus = {PermissionState::PERMISSION_DENIED}, - .grantFlags = {PermissionFlag::PERMISSION_USER_FIXED} - }; - - PermissionStateFull permTestState4 = { - .permissionName = "ohos.permission.READ_IMAGEVIDEO", - .isGeneral = true, - .resDeviceID = {"local"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {PermissionFlag::PERMISSION_USER_SET} - }; - policy.permStateList.emplace_back(permTestState1); - policy.permStateList.emplace_back(permTestState2); - policy.permStateList.emplace_back(permTestState3); - policy.permStateList.emplace_back(permTestState4); - PreparePermStateListExt(policy); -} - -void PreparePermDefList(HapPolicyParams &policy) -{ - PermissionDef permissionDefAlpha; - permissionDefAlpha.permissionName = TEST_PERMISSION_NAME_ALPHA; - permissionDefAlpha.bundleName = TEST_BUNDLE_NAME; - permissionDefAlpha.grantMode = GrantMode::USER_GRANT; - permissionDefAlpha.availableLevel = APL_NORMAL; - permissionDefAlpha.provisionEnable = false; - permissionDefAlpha.distributedSceneEnable = false; - - PermissionDef permissionDefBeta; - permissionDefBeta.permissionName = TEST_PERMISSION_NAME_BETA; - permissionDefBeta.bundleName = TEST_BUNDLE_NAME; - permissionDefBeta.grantMode = GrantMode::SYSTEM_GRANT; - permissionDefBeta.availableLevel = APL_NORMAL; - permissionDefBeta.provisionEnable = false; - permissionDefBeta.distributedSceneEnable = false; - - policy.permList.emplace_back(permissionDefAlpha); - policy.permList.emplace_back(permissionDefBeta); -} - -void AccessTokenKitExtensionTest::SetUp() -{ - selfTokenId_ = GetSelfTokenID(); - g_infoManagerTestInfoParms = g_infoManagerTestInfoParmsBak; - g_infoManagerTestPolicyPrams = g_infoManagerTestPolicyPramsBak; - HapInfoParams info = { - .userID = TEST_USER_ID, - .bundleName = TEST_BUNDLE_NAME, - .instIndex = 0, - .appIDDesc = "appIDDesc", - .apiVersion = DEFAULT_API_VERSION, - .isSystemApp = true - }; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "domain" - }; - PreparePermDefList(policy); - PreparePermStateList(policy); - policy.permStateList.emplace_back(g_grantPermissionReq); - policy.permStateList.emplace_back(g_revokePermissionReq); - AccessTokenKit::AllocHapToken(info, policy); - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - LOGI(ATM_DOMAIN, ATM_TAG, "SetUp ok."); -} - -void AccessTokenKitExtensionTest::TearDown() -{ - AccessTokenID tokenId = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenId); - tokenId = AccessTokenKit::GetHapTokenID(g_infoManagerTestNormalInfoParms.userID, - g_infoManagerTestNormalInfoParms.bundleName, - g_infoManagerTestNormalInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenId); - - tokenId = AccessTokenKit::GetHapTokenID(g_infoManagerTestSystemInfoParms.userID, - g_infoManagerTestSystemInfoParms.bundleName, - g_infoManagerTestSystemInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenId); - EXPECT_EQ(0, SetSelfTokenID(selfTokenId_)); -} - -void AccessTokenKitExtensionTest::AllocHapToken(std::vector& permissionDefs, - std::vector& permissionStateFulls, int32_t apiVersion) -{ - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, "accesstoken_location_test", 0); - AccessTokenKit::DeleteToken(tokenID); - - HapInfoParams info = g_locationTestInfo; - info.apiVersion = apiVersion; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "domain" - }; - - for (auto& permissionDef:permissionDefs) { - policy.permList.emplace_back(permissionDef); - } - - for (auto& permissionStateFull:permissionStateFulls) { - policy.permStateList.emplace_back(permissionStateFull); - } - - AccessTokenKit::AllocHapToken(info, policy); -} - -unsigned int AccessTokenKitExtensionTest::GetAccessTokenID(int userID, std::string bundleName, int instIndex) -{ - return AccessTokenKit::GetHapTokenID(userID, bundleName, instIndex); -} - -/** - * @tc.name: GetPermissionFlag006 - * @tc.desc: Get permission flag after grant permission. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitExtensionTest, GetPermissionFlag006, TestSize.Level1) -{ - static PermissionStateFull infoManagerTestStateA = { - .permissionName = "ohos.permission.CAMERA", - .isGeneral = true, - .resDeviceID = {"local2"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {PermissionFlag::PERMISSION_USER_SET} - }; - static HapPolicyParams infoManagerTestPolicyPrams1 = { - .apl = APL_NORMAL, - .domain = "test.domain2", - .permList = {}, - .permStateList = {infoManagerTestStateA} - }; - - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1); - AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; - ASSERT_NE(INVALID_TOKENID, tokenID); - - int ret = AccessTokenKit::RevokePermission(tokenID, "ohos.permission.CAMERA", PERMISSION_POLICY_FIXED); - ASSERT_EQ(RET_SUCCESS, ret); - - uint32_t flag; - ret = AccessTokenKit::GetPermissionFlag(tokenID, "ohos.permission.CAMERA", flag); - ASSERT_EQ(PERMISSION_POLICY_FIXED, flag); - ASSERT_EQ(RET_SUCCESS, ret); -} - -/** - * @tc.name: DumpTokenInfo001 - * @tc.desc: Get dump token information with invalid tokenID - * @tc.type: FUNC - * @tc.require:Issue Number - */ -HWTEST_F(AccessTokenKitExtensionTest, DumpTokenInfo001, TestSize.Level1) -{ - SetSelfTokenID(g_selfShellTokenId); - std::string dumpInfo; - AtmToolsParamInfo info; - info.tokenId = 123; - AccessTokenKit::DumpTokenInfo(info, dumpInfo); - ASSERT_EQ("invalid tokenId", dumpInfo); -} - -class CbCustomizeTest : public PermStateChangeCallbackCustomize { -public: - explicit CbCustomizeTest(const PermStateChangeScope &scopeInfo) - : PermStateChangeCallbackCustomize(scopeInfo) - { - } - - ~CbCustomizeTest() - {} - - virtual void PermStateChangeCallback(PermStateChangeInfo& result) - { - ready_ = true; - int32_t status = (result.permStateChangeType == 1) ? PERMISSION_GRANTED : PERMISSION_DENIED; - ASSERT_EQ(status, AccessTokenKit::VerifyAccessToken(result.tokenID, result.permissionName)); - } - - bool ready_; -}; - -/** - * @tc.name: RegisterSelfPermStateChangeCallback001 - * @tc.desc: RegisterSelfPermStateChangeCallback permList - * @tc.type: FUNC - * @tc.require: issueI5NT1X - */ -HWTEST_F(AccessTokenKitExtensionTest, RegisterSelfPermStateChangeCallback001, TestSize.Level1) -{ - static PermissionStateFull infoManagerTestStateA = { - .permissionName = "ohos.permission.CAMERA", - .isGeneral = true, - .resDeviceID = {"local2"}, - .grantStatus = {PERMISSION_DENIED}, - .grantFlags = {1} - }; - static HapPolicyParams infoManagerTestPolicyPrams1 = { - .apl = APL_NORMAL, - .domain = "test.domain2", - .permList = {}, - .permStateList = {infoManagerTestStateA} - }; - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1); - AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; - ASSERT_NE(INVALID_TOKENID, tokenID); - - PermStateChangeScope scopeInfo; - scopeInfo.permList = {"ohos.permission.CAMERA"}; - scopeInfo.tokenIDs = {tokenID}; - auto callbackPtr = std::make_shared(scopeInfo); - callbackPtr->ready_ = false; - - SetSelfTokenID(tokenID); - int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); - ASSERT_EQ(RET_SUCCESS, res); - SetSelfTokenID(selfTokenId_); - - res = AccessTokenKit::GrantPermission(tokenID, "ohos.permission.CAMERA", 2); - ASSERT_EQ(RET_SUCCESS, res); - - res = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.CAMERA", false); - ASSERT_EQ(PERMISSION_GRANTED, res); - usleep(500000); // 500000us = 0.5s - EXPECT_EQ(true, callbackPtr->ready_); - - callbackPtr->ready_ = false; - - res = AccessTokenKit::RevokePermission(tokenID, "ohos.permission.CAMERA", 2); - ASSERT_EQ(RET_SUCCESS, res); - usleep(500000); // 500000us = 0.5s - EXPECT_EQ(true, callbackPtr->ready_); - - SetSelfTokenID(tokenID); - res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr); - ASSERT_EQ(RET_SUCCESS, res); - SetSelfTokenID(selfTokenId_); - - res = AccessTokenKit::DeleteToken(tokenID); - ASSERT_EQ(RET_SUCCESS, res); -} - -/** - * @tc.name: RegisterSelfPermStateChangeCallback002 - * @tc.desc: RegisterSelfPermStateChangeCallback permList - * @tc.type: FUNC - * @tc.require: issueI5NT1X - */ -HWTEST_F(AccessTokenKitExtensionTest, RegisterSelfPermStateChangeCallback002, TestSize.Level1) -{ - static PermissionStateFull infoManagerTestStateA = { - .permissionName = "ohos.permission.CAMERA", - .isGeneral = true, - .resDeviceID = {"local2"}, - .grantStatus = {PERMISSION_DENIED}, - .grantFlags = {1} - }; - static PermissionStateFull infoManagerTestStateB = { - .permissionName = "ohos.permission.GET_BUNDLE_INFO", - .isGeneral = true, - .resDeviceID = {"local2"}, - .grantStatus = {PERMISSION_DENIED}, - .grantFlags = {1} - }; - static HapPolicyParams infoManagerTestPolicyPrams1 = { - .apl = APL_NORMAL, - .domain = "test.domain2", - .permList = {}, - .permStateList = {infoManagerTestStateA, infoManagerTestStateB} - }; - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1); - AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; - ASSERT_NE(INVALID_TOKENID, tokenID); - - PermStateChangeScope scopeInfo; - scopeInfo.permList = {"ohos.permission.CAMERA"}; - scopeInfo.tokenIDs = {tokenID}; - auto callbackPtr = std::make_shared(scopeInfo); - callbackPtr->ready_ = false; - - SetSelfTokenID(tokenID); - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr)); - SetSelfTokenID(selfTokenId_); - - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GrantPermission(tokenID, "ohos.permission.CAMERA", 2)); - usleep(500000); // 500000us = 0.5s - EXPECT_EQ(true, callbackPtr->ready_); - - callbackPtr->ready_ = false; - - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RevokePermission(tokenID, "ohos.permission.CAMERA", 2)); - usleep(500000); // 500000us = 0.5s - EXPECT_EQ(true, callbackPtr->ready_); - - callbackPtr->ready_ = false; - - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GrantPermission(tokenID, "ohos.permission.GET_BUNDLE_INFO", 2)); - usleep(500000); // 500000us = 0.5s - EXPECT_EQ(false, callbackPtr->ready_); - - SetSelfTokenID(tokenID); - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr)); - SetSelfTokenID(selfTokenId_); - - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); -} - -/** - * @tc.name: RegisterSelfPermStateChangeCallback003 - * @tc.desc: RegisterSelfPermStateChangeCallback permList - * @tc.type: FUNC - * @tc.require: issueI5NT1X - */ -HWTEST_F(AccessTokenKitExtensionTest, RegisterSelfPermStateChangeCallback003, TestSize.Level1) -{ - static PermissionStateFull infoManagerTestStateA = { - .permissionName = "ohos.permission.CAMERA", - .isGeneral = true, - .resDeviceID = {"local2"}, - .grantStatus = {PERMISSION_DENIED}, - .grantFlags = {1} - }; - static HapPolicyParams infoManagerTestPolicyPrams1 = { - .apl = APL_NORMAL, - .domain = "test.domain2", - .permList = {}, - .permStateList = {infoManagerTestStateA} - }; - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1); - AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; - ASSERT_NE(INVALID_TOKENID, tokenID); - - PermStateChangeScope scopeInfo; - scopeInfo.permList = {}; - scopeInfo.tokenIDs = {tokenID}; - auto callbackPtr = std::make_shared(scopeInfo); - callbackPtr->ready_ = false; - - SetSelfTokenID(tokenID); - int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); - ASSERT_EQ(RET_SUCCESS, res); - SetSelfTokenID(selfTokenId_); - - res = AccessTokenKit::GrantPermission(tokenID, "ohos.permission.CAMERA", 2); - ASSERT_EQ(RET_SUCCESS, res); - - res = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.CAMERA", false); - ASSERT_EQ(PERMISSION_GRANTED, res); - usleep(500000); // 500000us = 0.5s - EXPECT_EQ(true, callbackPtr->ready_); - - callbackPtr->ready_ = false; - - res = AccessTokenKit::RevokePermission(tokenID, "ohos.permission.CAMERA", 2); - ASSERT_EQ(RET_SUCCESS, res); - usleep(500000); // 500000us = 0.5s - EXPECT_EQ(true, callbackPtr->ready_); - - SetSelfTokenID(tokenID); - res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr); - ASSERT_EQ(RET_SUCCESS, res); - SetSelfTokenID(selfTokenId_); - - res = AccessTokenKit::DeleteToken(tokenID); - ASSERT_EQ(RET_SUCCESS, res); -} - -/** - * @tc.name: RegisterSelfPermStateChangeCallback004 - * @tc.desc: RegisterSelfPermStateChangeCallback permList - * @tc.type: FUNC - * @tc.require: issueI5NT1X - */ -HWTEST_F(AccessTokenKitExtensionTest, RegisterSelfPermStateChangeCallback004, TestSize.Level1) -{ - static PermissionStateFull infoManagerTestStateA = { - .permissionName = "ohos.permission.CAMERA", - .isGeneral = true, - .resDeviceID = {"local2"}, - .grantStatus = {PERMISSION_DENIED}, - .grantFlags = {1} - }; - static PermissionStateFull infoManagerTestStateB = { - .permissionName = "ohos.permission.GET_BUNDLE_INFO", - .isGeneral = true, - .resDeviceID = {"local2"}, - .grantStatus = {PERMISSION_DENIED}, - .grantFlags = {1} - }; - static HapPolicyParams infoManagerTestPolicyPrams1 = { - .apl = APL_NORMAL, - .domain = "test.domain2", - .permStateList = {infoManagerTestStateA, infoManagerTestStateB} - }; - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1); - AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; - ASSERT_NE(INVALID_TOKENID, tokenID); - - PermStateChangeScope scopeInfo; - scopeInfo.permList = {"ohos.permission.CAMERA", "ohos.permission.GET_BUNDLE_INFO"}; - scopeInfo.tokenIDs = {tokenID}; - auto callbackPtr = std::make_shared(scopeInfo); - callbackPtr->ready_ = false; - - SetSelfTokenID(tokenID); - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr)); - SetSelfTokenID(selfTokenId_); - - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GrantPermission(tokenID, "ohos.permission.CAMERA", 2)); - usleep(500000); // 500000us = 0.5s - EXPECT_EQ(true, callbackPtr->ready_); - - callbackPtr->ready_ = false; - - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RevokePermission(tokenID, "ohos.permission.CAMERA", 2)); - usleep(500000); // 500000us = 0.5s - EXPECT_EQ(true, callbackPtr->ready_); - - callbackPtr->ready_ = false; - - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GrantPermission(tokenID, "ohos.permission.GET_BUNDLE_INFO", 2)); - usleep(500000); // 500000us = 0.5s - EXPECT_EQ(true, callbackPtr->ready_); - - callbackPtr->ready_ = false; - - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RevokePermission(tokenID, "ohos.permission.GET_BUNDLE_INFO", 2)); - usleep(500000); // 500000us = 0.5s - EXPECT_EQ(true, callbackPtr->ready_); - - SetSelfTokenID(tokenID); - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr)); - - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); -} - -/** - * @tc.name: RegisterSelfPermStateChangeCallback005 - * @tc.desc: RegisterSelfPermStateChangeCallback permList - * @tc.type: FUNC - * @tc.require: issueI5NT1X - */ -HWTEST_F(AccessTokenKitExtensionTest, RegisterSelfPermStateChangeCallback005, TestSize.Level1) -{ - static PermissionStateFull infoManagerTestStateA = { - .permissionName = "ohos.permission.CAMERA", - .isGeneral = true, - .resDeviceID = {"local2"}, - .grantStatus = {PERMISSION_DENIED}, - .grantFlags = {1} - }; - static HapPolicyParams infoManagerTestPolicyPrams1 = { - .apl = APL_NORMAL, - .domain = "test.domain2", - .permList = {}, - .permStateList = {infoManagerTestStateA} - }; - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1); - AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; - ASSERT_NE(INVALID_TOKENID, tokenID); - - PermStateChangeScope scopeInfo; - scopeInfo.permList = {"ohos.permission.INVALID"}; - scopeInfo.tokenIDs = {tokenID}; - auto callbackPtr1 = std::make_shared(scopeInfo); - callbackPtr1->ready_ = false; - - SetSelfTokenID(tokenID); - int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr1); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, res); - - scopeInfo.permList = {"ohos.permission.INVALID", "ohos.permission.CAMERA"}; - auto callbackPtr = std::make_shared(scopeInfo); - res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); - ASSERT_EQ(RET_SUCCESS, res); - SetSelfTokenID(selfTokenId_); - - res = AccessTokenKit::GrantPermission(tokenID, "ohos.permission.CAMERA", 2); - ASSERT_EQ(RET_SUCCESS, res); - - res = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.CAMERA", false); - ASSERT_EQ(PERMISSION_GRANTED, res); - usleep(500000); // 500000us = 0.5s - EXPECT_EQ(true, callbackPtr->ready_); - - callbackPtr->ready_ = false; - - res = AccessTokenKit::RevokePermission(tokenID, "ohos.permission.CAMERA", 2); - ASSERT_EQ(RET_SUCCESS, res); - usleep(500000); // 500000us = 0.5s - EXPECT_EQ(true, callbackPtr->ready_); - - SetSelfTokenID(tokenID); - res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr); - ASSERT_EQ(RET_SUCCESS, res); - - res = AccessTokenKit::DeleteToken(tokenID); - ASSERT_EQ(RET_SUCCESS, res); -} - -/** - * @tc.name: RegisterSelfPermStateChangeCallback006 - * @tc.desc: RegisterSelfPermStateChangeCallback with permList, whose size is 1024/1025 - * @tc.type: FUNC - * @tc.require: issueI5NT1X - */ -HWTEST_F(AccessTokenKitExtensionTest, RegisterSelfPermStateChangeCallback006, TestSize.Level1) -{ - static PermissionStateFull infoManagerTestStateA = { - .permissionName = "ohos.permission.GET_BUNDLE_INFO", - .isGeneral = true, - .resDeviceID = {"local2"}, - .grantStatus = {PERMISSION_DENIED}, - .grantFlags = {1} - }; - static HapPolicyParams infoManagerTestPolicyPrams1 = { - .apl = APL_NORMAL, - .domain = "test.domain2", - .permList = {}, - .permStateList = {infoManagerTestStateA} - }; - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1); - AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; - ASSERT_NE(INVALID_TOKENID, tokenID); - SetSelfTokenID(tokenID); - - PermStateChangeScope scopeInfo; - scopeInfo.permList = {}; - scopeInfo.tokenIDs = {tokenID}; - for (int32_t i = 1; i <= 1025; i++) { // 1025 is a invalid size - scopeInfo.permList.emplace_back("ohos.permission.GET_BUNDLE_INFO"); - if (i == 1025) { // 1025 is a invalid size - auto callbackPtr = std::make_shared(scopeInfo); - int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, res); - break; - } - auto callbackPtr = std::make_shared(scopeInfo); - int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); - ASSERT_EQ(RET_SUCCESS, res); - res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr); - ASSERT_EQ(RET_SUCCESS, res); - } - SetSelfTokenID(selfTokenId_); - - int32_t res = AccessTokenKit::DeleteToken(tokenID); - ASSERT_EQ(RET_SUCCESS, res); -} - -/** - * @tc.name: RegisterSelfPermStateChangeCallback007 - * @tc.desc: RegisterSelfPermStateChangeCallback without set TokenID. - * @tc.type: FUNC - * @tc.require: issueI5NT1X - */ -HWTEST_F(AccessTokenKitExtensionTest, RegisterSelfPermStateChangeCallback007, TestSize.Level1) -{ - static PermissionStateFull infoManagerTestStateA = { - .permissionName = "ohos.permission.CAMERA", - .isGeneral = true, - .resDeviceID = {"local2"}, - .grantStatus = {PERMISSION_DENIED}, - .grantFlags = {1} - }; - static HapPolicyParams infoManagerTestPolicyPrams1 = { - .apl = APL_NORMAL, - .domain = "test.domain2", - .permList = {}, - .permStateList = {infoManagerTestStateA} - }; - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1); - AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; - ASSERT_NE(INVALID_TOKENID, tokenID); - - PermStateChangeScope scopeInfo; - scopeInfo.permList = {"ohos.permission.CAMERA"}; - scopeInfo.tokenIDs = {tokenID}; - auto callbackPtr = std::make_shared(scopeInfo); - callbackPtr->ready_ = false; - - int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, res); - - res = AccessTokenKit::DeleteToken(tokenID); - ASSERT_EQ(RET_SUCCESS, res); -} - -/** - * @tc.name: RegisterSelfPermStateChangeCallback008 - * @tc.desc: RegisterSelfPermStateChangeCallback with none or two tokenIDs. - * @tc.type: FUNC - * @tc.require: issueI5NT1X - */ -HWTEST_F(AccessTokenKitExtensionTest, RegisterSelfPermStateChangeCallback008, TestSize.Level1) -{ - static PermissionStateFull infoManagerTestStateA = { - .permissionName = "ohos.permission.CAMERA", - .isGeneral = true, - .resDeviceID = {"local2"}, - .grantStatus = {PERMISSION_DENIED}, - .grantFlags = {1} - }; - static HapPolicyParams infoManagerTestPolicyPrams1 = { - .apl = APL_NORMAL, - .domain = "test.domain2", - .permList = {}, - .permStateList = {infoManagerTestStateA} - }; - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1); - AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; - ASSERT_NE(INVALID_TOKENID, tokenID); - - HapInfoParams g_infoManagerTestInfoParms2 = { - .userID = 1, - .bundleName = "accesstoken_test_2", - .instIndex = 0, - .appIDDesc = "test2", - .apiVersion = DEFAULT_API_VERSION - }; - - AccessTokenIDEx tokenIdEx2 = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms2, - infoManagerTestPolicyPrams1); - AccessTokenID tokenID2 = tokenIdEx2.tokenIdExStruct.tokenID; - ASSERT_NE(INVALID_TOKENID, tokenID2); - - PermStateChangeScope scopeInfo; - scopeInfo.permList = {"ohos.permission.CAMERA"}; - scopeInfo.tokenIDs = {}; - auto callbackPtr1 = std::make_shared(scopeInfo); - callbackPtr1->ready_ = false; - - SetSelfTokenID(tokenID); - int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr1); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, res); - - scopeInfo.tokenIDs = {tokenID, tokenID2}; - auto callbackPtr = std::make_shared(scopeInfo); - callbackPtr->ready_ = false; - - res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, res); - - SetSelfTokenID(selfTokenId_); - res = AccessTokenKit::DeleteToken(tokenID); - ASSERT_EQ(RET_SUCCESS, res); - res = AccessTokenKit::DeleteToken(tokenID2); - ASSERT_EQ(RET_SUCCESS, res); -} - -/** - * @tc.name: RegisterSelfPermStateChangeCallback009 - * @tc.desc: RegisterSelfPermStateChangeCallback - * @tc.type: FUNC - * @tc.require: issueI5NT1X - */ -HWTEST_F(AccessTokenKitExtensionTest, RegisterSelfPermStateChangeCallback009, TestSize.Level1) -{ - static PermissionStateFull infoManagerTestStateA = { - .permissionName = "ohos.permission.CAMERA", - .isGeneral = true, - .resDeviceID = {"local2"}, - .grantStatus = {PERMISSION_DENIED}, - .grantFlags = {1} - }; - static HapPolicyParams infoManagerTestPolicyPrams1 = { - .apl = APL_NORMAL, - .domain = "test.domain2", - .permList = {}, - .permStateList = {infoManagerTestStateA} - }; - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1); - AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; - ASSERT_NE(INVALID_TOKENID, tokenID); - - PermStateChangeScope scopeInfo; - scopeInfo.permList = {}; - scopeInfo.tokenIDs = {tokenID}; - std::vector> callbackList; - SetSelfTokenID(tokenID); - - for (int32_t i = 0; i < 200; i++) { // 200 is the max size - if (i == 200) { // 200 is the max size - auto callbackPtr = std::make_shared(scopeInfo); - int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); - ASSERT_EQ(AccessTokenError::ERR_CALLBACKS_EXCEED_LIMITATION, res); - break; - } - auto callbackPtr = std::make_shared(scopeInfo); - int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); - ASSERT_EQ(RET_SUCCESS, res); - callbackList.emplace_back(callbackPtr); - } - for (int32_t i = 0; i < 200; i++) { // release 200 callback - auto callbackPtr = callbackList[i]; - int32_t res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr); - ASSERT_EQ(RET_SUCCESS, res); - } - callbackList.clear(); - SetSelfTokenID(selfTokenId_); - - int32_t res = AccessTokenKit::DeleteToken(tokenID); - ASSERT_EQ(RET_SUCCESS, res); -} - -/** - * @tc.name: RegisterSelfPermStateChangeCallback010 - * @tc.desc: RegisterSelfPermStateChangeCallback with nullptr - * @tc.type: FUNC - * @tc.require: issueI5NT1X - */ -HWTEST_F(AccessTokenKitExtensionTest, RegisterSelfPermStateChangeCallback010, TestSize.Level1) -{ - static PermissionStateFull infoManagerTestStateA = { - .permissionName = "ohos.permission.CAMERA", - .isGeneral = true, - .resDeviceID = {"local2"}, - .grantStatus = {PERMISSION_DENIED}, - .grantFlags = {1} - }; - static HapPolicyParams infoManagerTestPolicyPrams1 = { - .apl = APL_NORMAL, - .domain = "test.domain2", - .permList = {}, - .permStateList = {infoManagerTestStateA} - }; - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1); - AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; - ASSERT_NE(INVALID_TOKENID, tokenID); - - SetSelfTokenID(tokenID); - int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(nullptr); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, res); - SetSelfTokenID(selfTokenId_); - - res = AccessTokenKit::DeleteToken(tokenID); - ASSERT_EQ(RET_SUCCESS, res); -} - -/** - * @tc.name: UnRegisterSelfPermStateChangeCallback001 - * @tc.desc: UnRegisterSelfPermStateChangeCallback with invalid input. - * @tc.type: FUNC - * @tc.require: issueI5NT1X - */ -HWTEST_F(AccessTokenKitExtensionTest, UnRegisterSelfPermStateChangeCallback001, TestSize.Level1) -{ - static PermissionStateFull infoManagerTestStateA = { - .permissionName = "ohos.permission.CAMERA", - .isGeneral = true, - .resDeviceID = {"local2"}, - .grantStatus = {PERMISSION_DENIED}, - .grantFlags = {1} - }; - static HapPolicyParams infoManagerTestPolicyPrams1 = { - .apl = APL_NORMAL, - .domain = "test.domain2", - .permList = {}, - .permStateList = {infoManagerTestStateA} - }; - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1); - AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; - ASSERT_NE(INVALID_TOKENID, tokenID); - - PermStateChangeScope scopeInfo; - scopeInfo.permList = {}; - scopeInfo.tokenIDs = {tokenID}; - auto callbackPtr = std::make_shared(scopeInfo); - callbackPtr->ready_ = false; - - SetSelfTokenID(tokenID); - int32_t res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr); - ASSERT_EQ(AccessTokenError::ERR_INTERFACE_NOT_USED_TOGETHER, res); - SetSelfTokenID(selfTokenId_); -} - -/** - * @tc.name: UnRegisterSelfPermStateChangeCallback002 - * @tc.desc: UnRegisterSelfPermStateChangeCallback repeatedly. - * @tc.type: FUNC - * @tc.require: issueI5NT1X - */ -HWTEST_F(AccessTokenKitExtensionTest, UnRegisterSelfPermStateChangeCallback002, TestSize.Level1) -{ - static PermissionStateFull infoManagerTestStateA = { - .permissionName = "ohos.permission.CAMERA", - .isGeneral = true, - .resDeviceID = {"local2"}, - .grantStatus = {PERMISSION_DENIED}, - .grantFlags = {1} - }; - static HapPolicyParams infoManagerTestPolicyPrams1 = { - .apl = APL_NORMAL, - .domain = "test.domain2", - .permList = {}, - .permStateList = {infoManagerTestStateA} - }; - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1); - AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; - ASSERT_NE(INVALID_TOKENID, tokenID); - - PermStateChangeScope scopeInfo; - scopeInfo.permList = {}; - scopeInfo.tokenIDs = {tokenID}; - auto callbackPtr = std::make_shared(scopeInfo); - callbackPtr->ready_ = false; - - SetSelfTokenID(tokenID); - int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); - ASSERT_EQ(RET_SUCCESS, res); - res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); - ASSERT_EQ(AccessTokenError::ERR_CALLBACK_ALREADY_EXIST, res); - res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr); - ASSERT_EQ(RET_SUCCESS, res); - res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr); - ASSERT_EQ(AccessTokenError::ERR_INTERFACE_NOT_USED_TOGETHER, res); - SetSelfTokenID(selfTokenId_); - - res = AccessTokenKit::DeleteToken(tokenID); - ASSERT_EQ(RET_SUCCESS, res); -} - -/** - * @tc.name: UnRegisterSelfPermStateChangeCallback003 - * @tc.desc: UnRegisterSelfPermStateChangeCallback permList - * @tc.type: FUNC - * @tc.require: issueI5NT1X - */ -HWTEST_F(AccessTokenKitExtensionTest, UnRegisterSelfPermStateChangeCallback003, TestSize.Level1) -{ - static PermissionStateFull infoManagerTestStateA = { - .permissionName = "ohos.permission.CAMERA", - .isGeneral = true, - .resDeviceID = {"local2"}, - .grantStatus = {PERMISSION_DENIED}, - .grantFlags = {1} - }; - static HapPolicyParams infoManagerTestPolicyPrams1 = { - .apl = APL_NORMAL, - .domain = "test.domain2", - .permList = {}, - .permStateList = {infoManagerTestStateA} - }; - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1); - AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; - ASSERT_NE(INVALID_TOKENID, tokenID); - - PermStateChangeScope scopeInfo; - scopeInfo.permList = {"ohos.permission.CAMERA"}; - scopeInfo.tokenIDs = {tokenID}; - auto callbackPtr = std::make_shared(scopeInfo); - callbackPtr->ready_ = false; - - SetSelfTokenID(tokenID); - int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); - ASSERT_EQ(RET_SUCCESS, res); - - res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr); - ASSERT_EQ(RET_SUCCESS, res); - SetSelfTokenID(selfTokenId_); - - callbackPtr->ready_ = false; - - res = AccessTokenKit::GrantPermission(tokenID, "ohos.permission.CAMERA", 2); - ASSERT_EQ(RET_SUCCESS, res); - usleep(500000); // 500000us = 0.5s - ASSERT_EQ(false, callbackPtr->ready_); - - callbackPtr->ready_ = false; - - res = AccessTokenKit::RevokePermission(tokenID, "ohos.permission.CAMERA", 2); - ASSERT_EQ(RET_SUCCESS, res); - usleep(500000); // 500000us = 0.5s - ASSERT_EQ(false, callbackPtr->ready_); - - res = AccessTokenKit::DeleteToken(tokenID); - ASSERT_EQ(RET_SUCCESS, res); -} - -/** - * @tc.name: UnRegisterSelfPermStateChangeCallback004 - * @tc.desc: UnRegisterSelfPermStateChangeCallback permList - * @tc.type: FUNC - * @tc.require: issueI5NT1X - */ -HWTEST_F(AccessTokenKitExtensionTest, UnRegisterSelfPermStateChangeCallback004, TestSize.Level1) -{ - static PermissionStateFull infoManagerTestStateA = { - .permissionName = "ohos.permission.CAMERA", - .isGeneral = true, - .resDeviceID = {"local2"}, - .grantStatus = {PERMISSION_DENIED}, - .grantFlags = {1} - }; - static PermissionStateFull infoManagerTestStateB = { - .permissionName = "ohos.permission.GET_BUNDLE_INFO", - .isGeneral = true, - .resDeviceID = {"local2"}, - .grantStatus = {PERMISSION_DENIED}, - .grantFlags = {1} - }; - static HapPolicyParams infoManagerTestPolicyPrams1 = { - .apl = APL_NORMAL, - .domain = "test.domain2", - .permList = {}, - .permStateList = {infoManagerTestStateA, infoManagerTestStateB} - }; - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1); - AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; - ASSERT_NE(INVALID_TOKENID, tokenID); - - PermStateChangeScope scopeInfo; - scopeInfo.permList = {"ohos.permission.CAMERA"}; - scopeInfo.tokenIDs = {tokenID}; - auto callbackPtr = std::make_shared(scopeInfo); - callbackPtr->ready_ = false; - - SetSelfTokenID(tokenID); - int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); - ASSERT_EQ(RET_SUCCESS, res); - - res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr); - ASSERT_EQ(RET_SUCCESS, res); - SetSelfTokenID(selfTokenId_); - - callbackPtr->ready_ = false; - - res = AccessTokenKit::GrantPermission(tokenID, "ohos.permission.CAMERA", 2); - ASSERT_EQ(RET_SUCCESS, res); - usleep(500000); // 500000us = 0.5s - ASSERT_EQ(false, callbackPtr->ready_); - - callbackPtr->ready_ = false; - - res = AccessTokenKit::RevokePermission(tokenID, "ohos.permission.CAMERA", 2); - ASSERT_EQ(RET_SUCCESS, res); - usleep(500000); // 500000us = 0.5s - ASSERT_EQ(false, callbackPtr->ready_); - - res = AccessTokenKit::DeleteToken(tokenID); - ASSERT_EQ(RET_SUCCESS, res); -} - -/** - * @tc.name: UnRegisterSelfPermStateChangeCallback005 - * @tc.desc: UnRegisterSelfPermStateChangeCallback permList - * @tc.type: FUNC - * @tc.require: issueI5NT1X - */ -HWTEST_F(AccessTokenKitExtensionTest, UnRegisterSelfPermStateChangeCallback005, TestSize.Level1) -{ - static PermissionStateFull infoManagerTestStateA = { - .permissionName = "ohos.permission.CAMERA", - .isGeneral = true, - .resDeviceID = {"local2"}, - .grantStatus = {PERMISSION_DENIED}, - .grantFlags = {1} - }; - static HapPolicyParams infoManagerTestPolicyPrams1 = { - .apl = APL_NORMAL, - .domain = "test.domain2", - .permList = {}, - .permStateList = {infoManagerTestStateA} - }; - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1); - AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; - ASSERT_NE(INVALID_TOKENID, tokenID); - - PermStateChangeScope scopeInfo; - scopeInfo.permList = {}; - scopeInfo.tokenIDs = {tokenID}; - auto callbackPtr = std::make_shared(scopeInfo); - callbackPtr->ready_ = false; - - SetSelfTokenID(tokenID); - int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); - ASSERT_EQ(RET_SUCCESS, res); - SetSelfTokenID(selfTokenId_); - - SetSelfTokenID(tokenID); - res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr); - ASSERT_EQ(RET_SUCCESS, res); - SetSelfTokenID(selfTokenId_); - - callbackPtr->ready_ = false; - - res = AccessTokenKit::GrantPermission(tokenID, "ohos.permission.CAMERA", 2); - ASSERT_EQ(RET_SUCCESS, res); - usleep(500000); // 500000us = 0.5s - ASSERT_EQ(false, callbackPtr->ready_); - - callbackPtr->ready_ = false; - - res = AccessTokenKit::RevokePermission(tokenID, "ohos.permission.CAMERA", 2); - ASSERT_EQ(RET_SUCCESS, res); - usleep(500000); // 500000us = 0.5s - ASSERT_EQ(false, callbackPtr->ready_); - - res = AccessTokenKit::DeleteToken(tokenID); - ASSERT_EQ(RET_SUCCESS, res); -} - -/** - * @tc.name: UnRegisterSelfPermStateChangeCallback006 - * @tc.desc: UnRegisterSelfPermStateChangeCallback permList - * @tc.type: FUNC - * @tc.require: issueI5NT1X - */ -HWTEST_F(AccessTokenKitExtensionTest, UnRegisterSelfPermStateChangeCallback006, TestSize.Level1) -{ - static PermissionStateFull infoManagerTestStateA = { - .permissionName = "ohos.permission.CAMERA", - .isGeneral = true, - .resDeviceID = {"local2"}, - .grantStatus = {PERMISSION_DENIED}, - .grantFlags = {1} - }; - static PermissionStateFull infoManagerTestStateB = { - .permissionName = "ohos.permission.GET_BUNDLE_INFO", - .isGeneral = true, - .resDeviceID = {"local2"}, - .grantStatus = {PERMISSION_DENIED}, - .grantFlags = {1} - }; - static HapPolicyParams infoManagerTestPolicyPrams1 = { - .apl = APL_NORMAL, - .domain = "test.domain2", - .permList = {}, - .permStateList = {infoManagerTestStateA, infoManagerTestStateB} - }; - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1); - AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; - ASSERT_NE(INVALID_TOKENID, tokenID); - - PermStateChangeScope scopeInfo; - scopeInfo.permList = {"ohos.permission.CAMERA", "ohos.permission.GET_BUNDLE_INFO"}; - scopeInfo.tokenIDs = {tokenID}; - auto callbackPtr = std::make_shared(scopeInfo); - callbackPtr->ready_ = false; - - SetSelfTokenID(tokenID); - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr)); - - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr)); - SetSelfTokenID(selfTokenId_); - - callbackPtr->ready_ = false; - - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GrantPermission(tokenID, "ohos.permission.CAMERA", 2)); - usleep(500000); // 500000us = 0.5s - ASSERT_EQ(false, callbackPtr->ready_); - - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RevokePermission(tokenID, "ohos.permission.CAMERA", 2)); - usleep(500000); // 500000us = 0.5s - ASSERT_EQ(false, callbackPtr->ready_); - - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GrantPermission(tokenID, "ohos.permission.GET_BUNDLE_INFO", 2)); - usleep(500000); // 500000us = 0.5s - ASSERT_EQ(false, callbackPtr->ready_); - - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::RevokePermission(tokenID, "ohos.permission.GET_BUNDLE_INFO", 2)); - usleep(500000); // 500000us = 0.5s - ASSERT_EQ(false, callbackPtr->ready_); - - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); -} - -/** - * @tc.name: UnRegisterSelfPermStateChangeCallback007 - * @tc.desc: UnRegisterSelfPermStateChangeCallback permList - * @tc.type: FUNC - * @tc.require: issueI5NT1X - */ -HWTEST_F(AccessTokenKitExtensionTest, UnRegisterSelfPermStateChangeCallback007, TestSize.Level1) -{ - static PermissionStateFull infoManagerTestStateA = { - .permissionName = "ohos.permission.CAMERA", - .isGeneral = true, - .resDeviceID = {"local2"}, - .grantStatus = {PERMISSION_DENIED}, - .grantFlags = {1} - }; - static HapPolicyParams infoManagerTestPolicyPrams1 = { - .apl = APL_NORMAL, - .domain = "test.domain2", - .permList = {}, - .permStateList = {infoManagerTestStateA} - }; - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1); - AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; - ASSERT_NE(INVALID_TOKENID, tokenID); - - PermStateChangeScope scopeInfo; - scopeInfo.permList = {"ohos.permission.INVALID", "ohos.permission.CAMERA"}; - scopeInfo.tokenIDs = {tokenID}; - auto callbackPtr = std::make_shared(scopeInfo); - callbackPtr->ready_ = false; - - SetSelfTokenID(tokenID); - int32_t res = AccessTokenKit::RegisterSelfPermStateChangeCallback(callbackPtr); - ASSERT_EQ(RET_SUCCESS, res); - - res = AccessTokenKit::UnRegisterSelfPermStateChangeCallback(callbackPtr); - ASSERT_EQ(RET_SUCCESS, res); - SetSelfTokenID(selfTokenId_); - - callbackPtr->ready_ = false; - - res = AccessTokenKit::GrantPermission(tokenID, "ohos.permission.CAMERA", 2); - ASSERT_EQ(RET_SUCCESS, res); - usleep(500000); // 500000us = 0.5s - ASSERT_EQ(false, callbackPtr->ready_); - - callbackPtr->ready_ = false; - - res = AccessTokenKit::RevokePermission(tokenID, "ohos.permission.CAMERA", 2); - ASSERT_EQ(RET_SUCCESS, res); - usleep(500000); // 500000us = 0.5s - ASSERT_EQ(false, callbackPtr->ready_); - - res = AccessTokenKit::DeleteToken(tokenID); - ASSERT_EQ(RET_SUCCESS, res); -} - -/** - * @tc.name: GetVersion001 - * @tc.desc: GetVersion caller is normal app. - * @tc.type: FUNC - * @tc.require: issueI5NT1X - */ -HWTEST_F(AccessTokenKitExtensionTest, GetVersion001, TestSize.Level1) -{ - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestNormalInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); - - uint32_t version; - int32_t res = AccessTokenKit::GetVersion(version); - ASSERT_EQ(ERR_NOT_SYSTEM_APP, res); -} - -/** - * @tc.name: GetVersion002 - * @tc.desc: GetVersion caller is system app. - * @tc.type: FUNC - * @tc.require: issueI5NT1X - */ -HWTEST_F(AccessTokenKitExtensionTest, GetVersion002, TestSize.Level1) -{ - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestSystemInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); - - uint32_t version; - int32_t res = AccessTokenKit::GetVersion(version); - ASSERT_EQ(RET_SUCCESS, res); - ASSERT_EQ(DEFAULT_TOKEN_VERSION, version); -} - -/** - * @tc.name: PermStateChangeCallback001 - * @tc.desc: PermissionStateChangeCallback::PermStateChangeCallback function test. - * @tc.type: FUNC - * @tc.require: issueI61NS6 - */ -HWTEST_F(AccessTokenKitExtensionTest, PermStateChangeCallback001, TestSize.Level1) -{ - PermStateChangeInfo result = { - .permStateChangeType = 0, - .tokenID = 123, - .permissionName = "ohos.permission.CAMERA" - }; - - std::shared_ptr callbackPtr = nullptr; - std::shared_ptr callback = std::make_shared( - callbackPtr); - ASSERT_NE(callback, nullptr); - - callback->PermStateChangeCallback(result); - ASSERT_EQ(callback->customizedCallback_, nullptr); - callback->Stop(); -} - -class TestCallBack : public PermissionStateChangeCallbackStub { -public: - TestCallBack() = default; - virtual ~TestCallBack() = default; - - void PermStateChangeCallback(PermStateChangeInfo& result) - { - GTEST_LOG_(INFO) << "PermStateChangeCallback, tokenID is " << result.tokenID; - } -}; - -/** - * @tc.name: OnRemoteRequest001 - * @tc.desc: StateChangeCallbackStub::OnRemoteRequest function test - * @tc.type: FUNC - * @tc.require: issueI61A6M - */ -HWTEST_F(AccessTokenKitExtensionTest, OnRemoteRequest001, TestSize.Level1) -{ - PermStateChangeInfo info = { - .permStateChangeType = 0, - .tokenID = 123, - .permissionName = "ohos.permission.CAMERA" - }; - - TestCallBack callback; - PermissionStateChangeInfoParcel infoParcel; - infoParcel.changeInfo = info; - - OHOS::MessageParcel data; - std::string descriptor = "I don't know"; - data.WriteInterfaceToken(OHOS::Str8ToStr16(descriptor)); - ASSERT_EQ(true, data.WriteParcelable(&infoParcel)); - - OHOS::MessageParcel reply; - OHOS::MessageOption option(OHOS::MessageOption::TF_SYNC); - ASSERT_NE(0, - callback.OnRemoteRequest(static_cast(AccesstokenStateChangeInterfaceCode::PERMISSION_STATE_CHANGE), - data, reply, option)); // descriptor false - - ASSERT_EQ(true, data.WriteInterfaceToken(IPermissionStateCallback::GetDescriptor())); - ASSERT_EQ(true, data.WriteParcelable(&infoParcel)); - uint32_t code = 10; - ASSERT_NE(0, callback.OnRemoteRequest(code, data, reply, option)); // descriptor true + msgCode false -} - -/** - * @tc.name: CreatePermStateChangeCallback001 - * @tc.desc: AccessTokenManagerClient::CreatePermStateChangeCallback function test - * @tc.type: FUNC - * @tc.require: issueI61A6M - */ -HWTEST_F(AccessTokenKitExtensionTest, CreatePermStateChangeCallback001, TestSize.Level1) -{ - std::vector> callbackList; - - uint32_t times = 201; - for (uint32_t i = 0; i < times; i++) { - PermStateChangeScope scopeInfo; - scopeInfo.permList = {}; - scopeInfo.tokenIDs = {}; - auto callbackPtr = std::make_shared(scopeInfo); - callbackList.emplace_back(callbackPtr); - int32_t res = AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr); - - if (i == 200) { - EXPECT_EQ(AccessTokenError::ERR_CALLBACKS_EXCEED_LIMITATION, res); - break; - } - } - - for (uint32_t i = 0; i < 200; i++) { - ASSERT_EQ(0, AccessTokenKit::UnRegisterPermStateChangeCallback(callbackList[i])); - } - - std::shared_ptr customizedCb = nullptr; - AccessTokenKit::RegisterPermStateChangeCallback(customizedCb); // customizedCb is null -} - -/** - * @tc.name: InitProxy001 - * @tc.desc: AccessTokenManagerClient::InitProxy function test - * @tc.type: FUNC - * @tc.require: issueI61A6M - */ -HWTEST_F(AccessTokenKitExtensionTest, InitProxy001, TestSize.Level1) -{ - ASSERT_NE(nullptr, AccessTokenManagerClient::GetInstance().proxy_); - OHOS::sptr proxy = AccessTokenManagerClient::GetInstance().proxy_; // backup - AccessTokenManagerClient::GetInstance().proxy_ = nullptr; - ASSERT_EQ(nullptr, AccessTokenManagerClient::GetInstance().proxy_); - AccessTokenManagerClient::GetInstance().InitProxy(); // proxy_ is null - AccessTokenManagerClient::GetInstance().proxy_ = proxy; // recovery -} - -/** - * @tc.name: AllocHapToken020 - * @tc.desc: AccessTokenKit::AllocHapToken function test - * @tc.type: FUNC - * @tc.require: issueI61A6M - */ -HWTEST_F(AccessTokenKitExtensionTest, AllocHapToken020, TestSize.Level1) -{ - HapInfoParams info; - HapPolicyParams policy; - info.userID = -1; - AccessTokenKit::AllocHapToken(info, policy); - ASSERT_EQ(-1, info.userID); -} - -/** - * @tc.name: VerifyAccessToken005 - * @tc.desc: AccessTokenKit::VerifyAccessToken function test - * @tc.type: FUNC - * @tc.require: issueI61A6M - */ -HWTEST_F(AccessTokenKitExtensionTest, VerifyAccessToken005, TestSize.Level1) -{ - HapInfoParams info = { - .userID = TEST_USER_ID, - .bundleName = "accesstoken_test3", - .instIndex = 0, - .appIDDesc = "test3", - .apiVersion = DEFAULT_API_VERSION - }; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "test.domain3", - .permList = {g_infoManagerTestPermDef3}, - .permStateList = {g_infoManagerTestState3} - }; - - AccessTokenKit::AllocHapToken(info, policy); - AccessTokenID callerTokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, "accesstoken_test3", 0); - ASSERT_NE(INVALID_TOKENID, callerTokenID); - AccessTokenID firstTokenID; - - // ret = PERMISSION_GRANTED + firstTokenID = 0 - std::string permissionName = "ohos.permission.GET_BUNDLE_INFO"; - firstTokenID = 0; - ASSERT_EQ(PermissionState::PERMISSION_GRANTED, AccessTokenKit::VerifyAccessToken( - callerTokenID, firstTokenID, permissionName, false)); - - firstTokenID = 1; - // ret = PERMISSION_GRANTED + firstTokenID != 0 - ASSERT_EQ(PermissionState::PERMISSION_DENIED, AccessTokenKit::VerifyAccessToken( - callerTokenID, firstTokenID, permissionName, false)); - AccessTokenKit::DeleteToken(callerTokenID); - - callerTokenID = 0; - // ret = PERMISSION_DENIED - ASSERT_EQ(PermissionState::PERMISSION_DENIED, AccessTokenKit::VerifyAccessToken( - callerTokenID, firstTokenID, permissionName, false)); -} - -/** - * @tc.name: IsSystemAppByFullTokenIDTest001 - * @tc.desc: check systemapp level by TokenIDEx after AllocHapToken function set isSystemApp true. - * @tc.type: FUNC - * @tc.require: issueI60F1M - */ -HWTEST_F(AccessTokenKitExtensionTest, IsSystemAppByFullTokenIDTest001, TestSize.Level1) -{ - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestSystemInfoParms, g_infoManagerTestPolicyPrams); - AccessTokenIDEx tokenIdEx1 = AccessTokenKit::GetHapTokenIDEx(1, "accesstoken_test", 0); - ASSERT_EQ(tokenIdEx.tokenIDEx, tokenIdEx1.tokenIDEx); - bool res = TokenIdKit::IsSystemAppByFullTokenID(tokenIdEx.tokenIDEx); - ASSERT_EQ(true, res); - UpdateHapInfoParams info; - info.appIDDesc = g_infoManagerTestSystemInfoParms.appIDDesc; - info.apiVersion = g_infoManagerTestSystemInfoParms.apiVersion; - info.isSystemApp = false; - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UpdateHapToken(tokenIdEx, info, g_infoManagerTestPolicyPrams)); - tokenIdEx1 = AccessTokenKit::GetHapTokenIDEx(1, "accesstoken_test", 0); - ASSERT_EQ(tokenIdEx.tokenIDEx, tokenIdEx1.tokenIDEx); - res = TokenIdKit::IsSystemAppByFullTokenID(tokenIdEx.tokenIDEx); - ASSERT_EQ(false, res); -} - -/** - * @tc.name: IsSystemAppByFullTokenIDTest002 - * @tc.desc: check systemapp level by TokenIDEx after AllocHapToken function set isSystemApp false. - * @tc.type: FUNC - * @tc.require: issueI60F1M - */ -HWTEST_F(AccessTokenKitExtensionTest, IsSystemAppByFullTokenIDTest002, TestSize.Level1) -{ - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestNormalInfoParms, g_infoManagerTestPolicyPrams); - bool res = TokenIdKit::IsSystemAppByFullTokenID(tokenIdEx.tokenIDEx); - AccessTokenIDEx tokenIdEx1 = AccessTokenKit::GetHapTokenIDEx(1, "accesstoken_test", 0); - ASSERT_EQ(tokenIdEx.tokenIDEx, tokenIdEx1.tokenIDEx); - ASSERT_EQ(false, res); - UpdateHapInfoParams info; - info.appIDDesc = g_infoManagerTestNormalInfoParms.appIDDesc; - info.apiVersion = g_infoManagerTestNormalInfoParms.apiVersion; - info.isSystemApp = true; - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UpdateHapToken(tokenIdEx, info, g_infoManagerTestPolicyPrams)); - tokenIdEx1 = AccessTokenKit::GetHapTokenIDEx(1, "accesstoken_test", 0); - ASSERT_EQ(tokenIdEx.tokenIDEx, tokenIdEx1.tokenIDEx); - res = TokenIdKit::IsSystemAppByFullTokenID(tokenIdEx.tokenIDEx); - ASSERT_EQ(true, res); -} - -/** - * @tc.name: GetRenderTokenIDTest001 - * @tc.desc: TokenIdKit::GetRenderTokenID function test - * @tc.type: FUNC - * @tc.require: issueI7MOA1 - */ -HWTEST_F(AccessTokenKitExtensionTest, GetRenderTokenIDTest001, TestSize.Level1) -{ - uint64_t validTokenID = GetSelfTokenID(); - uint64_t retTokenId = validTokenID; - - retTokenId = TokenIdKit::GetRenderTokenID(validTokenID); - ASSERT_NE(retTokenId, validTokenID); - ASSERT_NE(retTokenId, INVALID_TOKENID); -} - -/** - * @tc.name: GetRenderTokenIDTest002 - * @tc.desc: TokenIdKit::GetRenderTokenID function test - * @tc.type: FUNC - * @tc.require: issueI7MOA1 - */ -HWTEST_F(AccessTokenKitExtensionTest, GetRenderTokenIDTest002, TestSize.Level1) -{ - uint64_t invalidTokenID = 0; - uint64_t retTokenId = 1; /* 1, for testing purposes */ - - retTokenId = TokenIdKit::GetRenderTokenID(invalidTokenID); - ASSERT_EQ(invalidTokenID, retTokenId); -} - -/** - * @tc.name: IsSystemAppByFullTokenIDTest003 - * @tc.desc: check systemapp level by TokenIDEx after AllocHapToken function set isSystemApp false. - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitExtensionTest, IsSystemAppByFullTokenIDTest003, TestSize.Level1) -{ - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestSystemInfoParms, g_infoManagerTestPolicyPrams); - AccessTokenIDEx tokenIdEx1 = AccessTokenKit::GetHapTokenIDEx(1, "accesstoken_test", 0); - ASSERT_EQ(tokenIdEx.tokenIDEx, tokenIdEx1.tokenIDEx); - bool res = AccessTokenKit::IsSystemAppByFullTokenID(tokenIdEx.tokenIDEx); - ASSERT_TRUE(res); - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenIdEx.tokenIdExStruct.tokenID)); -} - -/** - * @tc.name: GetRenderTokenIDTest003 - * @tc.desc: AccessTokenKit::GetRenderTokenID function test - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitExtensionTest, GetRenderTokenIDTest003, TestSize.Level1) -{ - uint64_t invalidTokenID = 0; - uint64_t retTokenId = 1; /* 1, for testing purposes */ - - retTokenId = AccessTokenKit::GetRenderTokenID(invalidTokenID); - ASSERT_EQ(invalidTokenID, retTokenId); -} - -#ifdef TOKEN_SYNC_ENABLE -namespace { -class TokenSyncCallbackStubTest : public TokenSyncCallbackStub { -public: - TokenSyncCallbackStubTest() = default; - virtual ~TokenSyncCallbackStubTest() = default; - - int32_t GetRemoteHapTokenInfo(const std::string& deviceID, AccessTokenID tokenID) override - { - return 0; - }; - int32_t DeleteRemoteHapTokenInfo(AccessTokenID tokenID) override - { - return 0; - }; - - int32_t UpdateRemoteHapTokenInfo(const HapTokenInfoForSync& tokenInfo) override - { - return 0; - }; -}; - -static const int32_t FAKE_SYNC_RET = 0xabcdef; -class TokenSyncCallbackImpl : public TokenSyncKitInterface { -public: - ~TokenSyncCallbackImpl() - {} - - int32_t GetRemoteHapTokenInfo(const std::string& deviceID, AccessTokenID tokenID) const override - { - LOGI(ATM_DOMAIN, ATM_TAG, "GetRemoteHapTokenInfo called."); - return FAKE_SYNC_RET; - }; - - int32_t DeleteRemoteHapTokenInfo(AccessTokenID tokenID) const override - { - LOGI(ATM_DOMAIN, ATM_TAG, "DeleteRemoteHapTokenInfo called."); - return FAKE_SYNC_RET; - }; - - int32_t UpdateRemoteHapTokenInfo(const HapTokenInfoForSync& tokenInfo) const override - { - LOGI(ATM_DOMAIN, ATM_TAG, "UpdateRemoteHapTokenInfo called."); - return FAKE_SYNC_RET; - }; -}; -}; - -/** - * @tc.name: TokenSyncCallbackStubTest001 - * @tc.desc: TokenSyncCallbackStub OnRemoteRequest deny test - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitExtensionTest, TokenSyncCallbackStubTest001, TestSize.Level1) -{ - TokenSyncCallbackStubTest callback; - - OHOS::MessageParcel data; - std::string descriptor = "I don't know"; - data.WriteInterfaceToken(OHOS::Str8ToStr16(descriptor)); - - OHOS::MessageParcel reply; - OHOS::MessageOption option(OHOS::MessageOption::TF_SYNC); - EXPECT_EQ(ERROR_IPC_REQUEST_FAIL, - callback.OnRemoteRequest(static_cast(TokenSyncCallbackInterfaceCode::GET_REMOTE_HAP_TOKEN_INFO), - data, reply, option)); // descriptor false -} - -/** - * @tc.name: TokenSyncCallbackStubTest002 - * @tc.desc: TokenSyncCallbackStub OnRemoteRequest err code - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitExtensionTest, TokenSyncCallbackStubTest002, TestSize.Level1) -{ - TokenSyncCallbackStubTest callback; - OHOS::MessageParcel data; - data.WriteInterfaceToken(ITokenSyncCallback::GetDescriptor()); - - OHOS::MessageParcel reply; - OHOS::MessageOption option(OHOS::MessageOption::TF_SYNC); - EXPECT_NE(0, callback.OnRemoteRequest(static_cast(0xff), // code false - data, reply, option)); -} - -/** - * @tc.name: TokenSyncCallbackStubTest003 - * @tc.desc: TokenSyncCallbackStub OnRemoteRequest deny call - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitExtensionTest, TokenSyncCallbackStubTest003, TestSize.Level1) -{ - TokenSyncCallbackStubTest callback; - OHOS::MessageParcel data; - data.WriteInterfaceToken(ITokenSyncCallback::GetDescriptor()); - - OHOS::MessageParcel reply; - OHOS::MessageOption option(OHOS::MessageOption::TF_SYNC); - EXPECT_EQ(0, callback.OnRemoteRequest( - static_cast(TokenSyncCallbackInterfaceCode::GET_REMOTE_HAP_TOKEN_INFO), - data, reply, option)); - EXPECT_EQ(ERR_IDENTITY_CHECK_FAILED, reply.ReadInt32()); - - data.WriteInterfaceToken(ITokenSyncCallback::GetDescriptor()); - EXPECT_EQ(0, callback.OnRemoteRequest( - static_cast(TokenSyncCallbackInterfaceCode::DELETE_REMOTE_HAP_TOKEN_INFO), - data, reply, option)); - EXPECT_EQ(ERR_IDENTITY_CHECK_FAILED, reply.ReadInt32()); - - data.WriteInterfaceToken(ITokenSyncCallback::GetDescriptor()); - EXPECT_EQ(0, callback.OnRemoteRequest( - static_cast(TokenSyncCallbackInterfaceCode::UPDATE_REMOTE_HAP_TOKEN_INFO), - data, reply, option)); - EXPECT_EQ(ERR_IDENTITY_CHECK_FAILED, reply.ReadInt32()); -} - -/** - * @tc.name: TokenSyncCallbackStubTest004 - * @tc.desc: TokenSyncCallbackStub OnRemoteRequest normal call - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitExtensionTest, TokenSyncCallbackStubTest004, TestSize.Level1) -{ - setuid(3020); // ACCESSTOKEN_UID - - TokenSyncCallbackStubTest callback; - OHOS::MessageParcel data; - OHOS::MessageParcel reply; - OHOS::MessageOption option(OHOS::MessageOption::TF_SYNC); - - data.WriteInterfaceToken(ITokenSyncCallback::GetDescriptor()); - data.WriteString("test deviceID"); // test deviceID - data.WriteUint32(0); // test tokenid - EXPECT_EQ(0, callback.OnRemoteRequest( - static_cast(TokenSyncCallbackInterfaceCode::GET_REMOTE_HAP_TOKEN_INFO), - data, reply, option)); - EXPECT_EQ(0, reply.ReadInt32()); - - data.WriteInterfaceToken(ITokenSyncCallback::GetDescriptor()); - data.WriteUint32(0); // test tokenid - EXPECT_EQ(0, callback.OnRemoteRequest( - static_cast(TokenSyncCallbackInterfaceCode::DELETE_REMOTE_HAP_TOKEN_INFO), - data, reply, option)); - EXPECT_EQ(0, reply.ReadInt32()); - - data.WriteInterfaceToken(ITokenSyncCallback::GetDescriptor()); - HapTokenInfoForSync info; - HapTokenInfoForSyncParcel tokenInfoParcel; - tokenInfoParcel.hapTokenInfoForSyncParams = info; - data.WriteParcelable(&tokenInfoParcel); - EXPECT_EQ(0, callback.OnRemoteRequest( - static_cast(TokenSyncCallbackInterfaceCode::UPDATE_REMOTE_HAP_TOKEN_INFO), - data, reply, option)); - EXPECT_EQ(0, reply.ReadInt32()); - setuid(0); // root uid -} - -/** - * @tc.name: TokenSyncCallbackTest001 - * @tc.desc: TokenSyncCallback inner call - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitExtensionTest, TokenSyncCallbackTest001, TestSize.Level1) -{ - TokenSyncCallback callback(nullptr); - EXPECT_EQ(nullptr, callback.tokenSyncCallback_); // test input - - std::shared_ptr ptr = std::make_shared(); - std::shared_ptr callbackImpl = std::make_shared(ptr); - EXPECT_NE(nullptr, callbackImpl->tokenSyncCallback_); - EXPECT_EQ(FAKE_SYNC_RET, callbackImpl->GetRemoteHapTokenInfo("test", 0)); // test input - EXPECT_EQ(FAKE_SYNC_RET, callbackImpl->DeleteRemoteHapTokenInfo(0)); // test input - HapTokenInfoForSync info; - EXPECT_EQ(FAKE_SYNC_RET, callbackImpl->UpdateRemoteHapTokenInfo(info)); // test input -} -#endif // TOKEN_SYNC_ENABLE - -/** - * @tc.name: GetPermissionManagerInfo001 - * @tc.desc: - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitExtensionTest, GetPermissionManagerInfo001, TestSize.Level1) -{ - PermissionGrantInfo info; - AccessTokenKit::GetPermissionManagerInfo(info); - ASSERT_EQ(false, info.grantBundleName.empty()); -} - -} // namespace AccessToken -} // namespace Security -} // namespace OHOS diff --git a/interfaces/innerkits/accesstoken/test/unittest/src/accesstoken_kit_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/src/accesstoken_kit_test.cpp deleted file mode 100644 index f68e74d52fca44917d0150fb9ae8eb3b5bbc517b..0000000000000000000000000000000000000000 --- a/interfaces/innerkits/accesstoken/test/unittest/src/accesstoken_kit_test.cpp +++ /dev/null @@ -1,3058 +0,0 @@ -/* - * Copyright (c) 2021-2024 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 "accesstoken_kit_test.h" -#include - -#include "access_token_error.h" -#include "accesstoken_common_log.h" -#include "i_accesstoken_manager.h" -#include "nativetoken_kit.h" -#include "permission_grant_info.h" -#include "permission_state_change_info_parcel.h" -#include "string_ex.h" -#include "token_setproc.h" -#define private public -#include "accesstoken_manager_client.h" -#undef private - -using namespace testing::ext; - -namespace OHOS { -namespace Security { -namespace AccessToken { -namespace { -static const int INVALID_DLP_TOKEN_FLAG = -1; -static constexpr int32_t DEFAULT_API_VERSION = 8; -static const int32_t INDEX_ZERO = 0; -static const int32_t INDEX_ONE = 1; -static const int32_t INDEX_TWO = 2; -static const int32_t INDEX_THREE = 3; -static const int32_t INDEX_FOUR = 4; -static const std::string TEST_PERMISSION_NAME_A_MICRO = "ohos.permission.MICROPHONE"; -static const std::string TEST_PERMISSION_NAME_A_CAMERA = "ohos.permission.SET_WIFI_INFO"; - -PermissionDef g_infoManagerTestPermDef1 = { - .permissionName = "ohos.permission.test1", - .bundleName = "accesstoken_test", - .grantMode = 1, - .availableLevel = APL_NORMAL, - .label = "label3", - .labelId = 1, - .description = "open the door", - .descriptionId = 1, - .availableType = MDM -}; - -PermissionDef g_infoManagerTestPermDef2 = { - .permissionName = "ohos.permission.test2", - .bundleName = "accesstoken_test", - .grantMode = 1, - .availableLevel = APL_NORMAL, - .label = "label3", - .labelId = 1, - .description = "break the door", - .descriptionId = 1, -}; - -PermissionStateFull g_infoManagerTestState1 = { - .permissionName = "ohos.permission.test1", - .isGeneral = true, - .resDeviceID = {"local3"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {1} -}; - -PermissionStateFull g_infoManagerTestState2 = { - .permissionName = "ohos.permission.test2", - .isGeneral = false, - .resDeviceID = {"device 1", "device 2"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED, PermissionState::PERMISSION_GRANTED}, - .grantFlags = {1, 2} -}; - -HapInfoParams g_infoManagerTestInfoParms = { - .userID = 1, - .bundleName = "accesstoken_test", - .instIndex = 0, - .appIDDesc = "test3", - .apiVersion = DEFAULT_API_VERSION, - .appDistributionType = "enterprise_mdm" -}; - -HapPolicyParams g_infoManagerTestPolicyPrams = { - .apl = APL_NORMAL, - .domain = "test.domain3", - .permList = {g_infoManagerTestPermDef1, g_infoManagerTestPermDef2}, - .permStateList = {g_infoManagerTestState1, g_infoManagerTestState2} -}; - -HapInfoParams g_infoManagerTestInfoParmsBak = g_infoManagerTestInfoParms; -HapPolicyParams g_infoManagerTestPolicyPramsBak = g_infoManagerTestPolicyPrams; - -HapInfoParams g_infoManagerTestNormalInfoParms = { - .userID = 1, - .bundleName = "accesstoken_test", - .instIndex = 0, - .appIDDesc = "test3", - .apiVersion = DEFAULT_API_VERSION, - .isSystemApp = false -}; - -HapInfoParams g_infoManagerTestSystemInfoParms = { - .userID = 1, - .bundleName = "accesstoken_test", - .instIndex = 0, - .appIDDesc = "test3", - .apiVersion = DEFAULT_API_VERSION, - .isSystemApp = true -}; -} -uint64_t GetNativeTokenTest(const char *processName, const char **perms, int32_t permNum) -{ - uint64_t tokenId; - NativeTokenInfoParams infoInstance = { - .dcapsNum = 0, - .permsNum = permNum, - .aclsNum = 0, - .dcaps = nullptr, - .perms = perms, - .acls = nullptr, - .aplStr = "system_core", - .processName = processName, - }; - - tokenId = GetAccessTokenId(&infoInstance); - AccessTokenKit::ReloadNativeTokenInfo(); - return tokenId; -} - -void NativeTokenGet() -{ - uint64_t tokenID; - const char **perms = new const char *[5]; // 5: array size - perms[INDEX_ZERO] = "ohos.permission.DISTRIBUTED_DATASYNC"; - perms[INDEX_ONE] = "ohos.permission.GRANT_SENSITIVE_PERMISSIONS"; - perms[INDEX_TWO] = "ohos.permission.REVOKE_SENSITIVE_PERMISSIONS"; - perms[INDEX_THREE] = "ohos.permission.GET_SENSITIVE_PERMISSIONS"; - perms[INDEX_FOUR] = "ohos.permission.DISABLE_PERMISSION_DIALOG"; - - tokenID = GetNativeTokenTest("TestCase", perms, 5); // 5: array size - EXPECT_EQ(0, SetSelfTokenID(tokenID)); - delete[] perms; -} - -void AccessTokenKitTest::SetUpTestCase() -{ - setuid(0); - // make test case clean - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestNormalInfoParms.userID, - g_infoManagerTestNormalInfoParms.bundleName, - g_infoManagerTestNormalInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestSystemInfoParms.userID, - g_infoManagerTestSystemInfoParms.bundleName, - g_infoManagerTestSystemInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenID); - - NativeTokenGet(); -} - -void AccessTokenKitTest::TearDownTestCase() -{ -} - -void TestPreparePermStateList(HapPolicyParams &policy) -{ - PermissionStateFull permStatMicro = { - .permissionName = TEST_PERMISSION_NAME_A_MICRO, - .isGeneral = true, - .resDeviceID = {"device3"}, - .grantStatus = {PermissionState::PERMISSION_DENIED}, - .grantFlags = {PermissionFlag::PERMISSION_USER_SET} - }; - PermissionStateFull permStatCamera = { - .permissionName = TEST_PERMISSION_NAME_A_CAMERA, - .isGeneral = true, - .resDeviceID = {"device3"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {PermissionFlag::PERMISSION_USER_FIXED} - }; - PermissionStateFull permStatAlpha = { - .permissionName = TEST_PERMISSION_NAME_ALPHA, - .isGeneral = true, - .resDeviceID = {"device3"}, - .grantStatus = {PermissionState::PERMISSION_DENIED}, - .grantFlags = {PermissionFlag::PERMISSION_USER_SET} - }; - PermissionStateFull permStatBeta = { - .permissionName = TEST_PERMISSION_NAME_BETA, - .isGeneral = true, - .resDeviceID = {"device3"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {PermissionFlag::PERMISSION_USER_FIXED} - }; - policy.permStateList.emplace_back(permStatMicro); - policy.permStateList.emplace_back(permStatCamera); - policy.permStateList.emplace_back(permStatAlpha); - policy.permStateList.emplace_back(permStatBeta); -} - -void TestPreparePermDefList(HapPolicyParams &policy) -{ - PermissionDef permissionDefBeta; - permissionDefBeta.permissionName = TEST_PERMISSION_NAME_BETA; - permissionDefBeta.bundleName = TEST_BUNDLE_NAME; - permissionDefBeta.grantMode = GrantMode::SYSTEM_GRANT; - permissionDefBeta.availableLevel = APL_NORMAL; - permissionDefBeta.provisionEnable = false; - permissionDefBeta.distributedSceneEnable = false; - - PermissionDef permissionDefAlpha; - permissionDefAlpha.permissionName = TEST_PERMISSION_NAME_ALPHA; - permissionDefAlpha.bundleName = TEST_BUNDLE_NAME; - permissionDefAlpha.grantMode = GrantMode::USER_GRANT; - permissionDefAlpha.availableLevel = APL_NORMAL; - permissionDefAlpha.provisionEnable = false; - permissionDefAlpha.distributedSceneEnable = false; - - policy.permList.emplace_back(permissionDefBeta); - policy.permList.emplace_back(permissionDefAlpha); -} - -void AccessTokenKitTest::SetUp() -{ - selfTokenId_ = GetSelfTokenID(); - g_infoManagerTestPolicyPrams = g_infoManagerTestPolicyPramsBak; - g_infoManagerTestInfoParms = g_infoManagerTestInfoParmsBak; - HapInfoParams info = { - .userID = TEST_USER_ID, - .bundleName = TEST_BUNDLE_NAME, - .instIndex = 0, - .appIDDesc = "appIDDesc", - .apiVersion = DEFAULT_API_VERSION - }; - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "domain" - }; - TestPreparePermDefList(policy); - TestPreparePermStateList(policy); - - AccessTokenKit::AllocHapToken(info, policy); - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); -} - -void AccessTokenKitTest::TearDown() -{ - AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenID); - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestNormalInfoParms.userID, - g_infoManagerTestNormalInfoParms.bundleName, - g_infoManagerTestNormalInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestSystemInfoParms.userID, - g_infoManagerTestSystemInfoParms.bundleName, - g_infoManagerTestSystemInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - EXPECT_EQ(0, SetSelfTokenID(selfTokenId_)); - - DeleteTestToken(); -} - -unsigned int AccessTokenKitTest::GetAccessTokenID(int userID, std::string bundleName, int instIndex) -{ - return AccessTokenKit::GetHapTokenID(userID, bundleName, instIndex); -} - -void AccessTokenKitTest::DeleteTestToken() const -{ - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); - int ret = AccessTokenKit::DeleteToken(tokenID); - if (tokenID != 0) { - ASSERT_EQ(RET_SUCCESS, ret); - } -} - -AccessTokenID AccessTokenKitTest::AllocTestToken( - const HapInfoParams& hapInfo, const HapPolicyParams& hapPolicy) const -{ - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(hapInfo, hapPolicy); - return tokenIdEx.tokenIdExStruct.tokenID; -} - -/** - * @tc.name: GetPermissionUsedType001 - * @tc.desc: Get hap permission visit type return invalid. - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, GetPermissionUsedType001, TestSize.Level1) -{ - std::string accessBluetooth = "ohos.permission.ACCESS_BLUETOOTH"; - - EXPECT_EQ(PermUsedTypeEnum::INVALID_USED_TYPE, - AccessTokenKit::GetPermissionUsedType(selfTokenId_, accessBluetooth)); - AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); - - EXPECT_EQ(PermUsedTypeEnum::INVALID_USED_TYPE, - AccessTokenKit::GetPermissionUsedType(0, accessBluetooth)); - - EXPECT_EQ(PermUsedTypeEnum::INVALID_USED_TYPE, - AccessTokenKit::GetPermissionUsedType(tokenID, "ohos.permission.ACCELEROMETER")); - - EXPECT_EQ(PermUsedTypeEnum::INVALID_USED_TYPE, - AccessTokenKit::GetPermissionUsedType(tokenID, "ohos.permission.xxxxx")); - - EXPECT_EQ(PermUsedTypeEnum::INVALID_USED_TYPE, - AccessTokenKit::GetPermissionUsedType(tokenID, accessBluetooth)); -} - -/** - * @tc.name: GetPermissionUsedType002 - * @tc.desc: Different grant permission modes get different visit type. - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, GetPermissionUsedType002, TestSize.Level1) -{ - std::string accessBluetooth = "ohos.permission.ACCESS_BLUETOOTH"; - std::string sendMessages = "ohos.permission.SEND_MESSAGES"; - std::string writeCalendar = "ohos.permission.WRITE_CALENDAR"; - PermissionStateFull testState1 = { - .permissionName = accessBluetooth, - .isGeneral = true, - .resDeviceID = {"local3"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {PermissionFlag::PERMISSION_COMPONENT_SET} - }; - PermissionStateFull testState2 = { - .permissionName = sendMessages, - .isGeneral = true, - .resDeviceID = {"local3"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {1} - }; - PermissionStateFull testState3 = { - .permissionName = writeCalendar, - .isGeneral = false, - .resDeviceID = {"local3"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {1} - }; - HapPolicyParams testPolicyPrams = { - .apl = APL_NORMAL, - .domain = "test.domain3", - .permStateList = {testState1, testState2, testState3} - }; - AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, testPolicyPrams); - - EXPECT_EQ(PermUsedTypeEnum::SEC_COMPONENT_TYPE, - AccessTokenKit::GetPermissionUsedType(tokenID, accessBluetooth)); - - EXPECT_EQ(PermUsedTypeEnum::NORMAL_TYPE, AccessTokenKit::GetPermissionUsedType(tokenID, sendMessages)); - - int32_t selfUid = getuid(); - EXPECT_EQ(0, SetSelfTokenID(tokenID)); - setuid(1); - EXPECT_EQ(PermUsedTypeEnum::INVALID_USED_TYPE, - AccessTokenKit::GetPermissionUsedType(tokenID, writeCalendar)); - setuid(selfUid); - ASSERT_EQ(0, SetSelfTokenID(selfTokenId_)); -} - -/** - * @tc.name: GetReqPermissions001 - * @tc.desc: Get user granted permission state info. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, GetReqPermissions001, TestSize.Level1) -{ - AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); - std::vector permStatList; - int res = AccessTokenKit::GetReqPermissions(tokenID, permStatList, false); - ASSERT_EQ(RET_SUCCESS, res); - ASSERT_EQ(static_cast(1), permStatList.size()); - ASSERT_EQ(TEST_PERMISSION_NAME_A_MICRO, permStatList[0].permissionName); - - res = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_A_MICRO, false); - ASSERT_EQ(res, permStatList[0].grantStatus[0]); -} - -/** - * @tc.name: GetReqPermissions002 - * @tc.desc: Get system granted permission state info. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, GetReqPermissions002, TestSize.Level1) -{ - AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); - std::vector permStatList; - int ret = AccessTokenKit::GetReqPermissions(tokenID, permStatList, true); - ASSERT_EQ(RET_SUCCESS, ret); - ASSERT_EQ(static_cast(1), permStatList.size()); - ASSERT_EQ(TEST_PERMISSION_NAME_A_CAMERA, permStatList[0].permissionName); - - ret = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_A_CAMERA, false); - ASSERT_EQ(ret, permStatList[0].grantStatus[0]); -} - -/** - * @tc.name: GetReqPermissions003 - * @tc.desc: Get user granted permission state info after clear request permission list. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, GetReqPermissions003, TestSize.Level1) -{ - AccessTokenIDEx tokenIdEx = AccessTokenKit::GetHapTokenIDEx(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; - ASSERT_NE(INVALID_TOKENID, tokenID); - - HapTokenInfo hapInfo; - int ret = AccessTokenKit::GetHapTokenInfo(tokenID, hapInfo); - ASSERT_EQ(RET_SUCCESS, ret); - - HapPolicyParams policy = { - .apl = APL_NORMAL, - .domain = "domain" - }; - policy.permStateList.clear(); - UpdateHapInfoParams info; - info.appIDDesc = "appIDDesc"; - info.apiVersion = DEFAULT_API_VERSION; - info.isSystemApp = false; - ret = AccessTokenKit::UpdateHapToken(tokenIdEx, info, policy); - ASSERT_EQ(RET_SUCCESS, ret); - - std::vector permStatUserList; - ret = AccessTokenKit::GetReqPermissions(tokenID, permStatUserList, false); - ASSERT_EQ(RET_SUCCESS, ret); - ASSERT_EQ(static_cast(0), permStatUserList.size()); - - std::vector permStatSystemList; - ret = AccessTokenKit::GetReqPermissions(tokenID, permStatSystemList, true); - ASSERT_EQ(RET_SUCCESS, ret); - ASSERT_EQ(static_cast(0), permStatSystemList.size()); -} - -/** - * @tc.name: GetReqPermissions004 - * @tc.desc: Get permission state info list that tokenID is invalid. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, GetReqPermissions004, TestSize.Level1) -{ - AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); - - std::vector permStatList; - int ret = AccessTokenKit::GetReqPermissions(TEST_TOKENID_INVALID, permStatList, false); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); - - AccessTokenKit::DeleteToken(tokenID); - - ret = AccessTokenKit::GetReqPermissions(tokenID, permStatList, false); - ASSERT_EQ(ERR_TOKENID_NOT_EXIST, ret); - ASSERT_EQ(static_cast(0), permStatList.size()); -} - -/** - * @tc.name: GetReqPermissions005 - * @tc.desc: GetReqPermissions is invoked multiple times. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, GetReqPermissions005, TestSize.Level0) -{ - AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); - for (int i = 0; i < CYCLE_TIMES; i++) { - std::vector permStatList; - int32_t ret = AccessTokenKit::GetReqPermissions(tokenID, permStatList, false); - ASSERT_EQ(RET_SUCCESS, ret); - ASSERT_EQ(static_cast(1), permStatList.size()); - ASSERT_EQ(TEST_PERMISSION_NAME_A_MICRO, permStatList[0].permissionName); - } -} - -/** - * @tc.name: GetPermissionFlag001 - * @tc.desc: Get permission flag after grant permission. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, GetPermissionFlag001, TestSize.Level1) -{ - AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); - int ret = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION_NAME_A_MICRO, PERMISSION_USER_FIXED); - ASSERT_EQ(RET_SUCCESS, ret); - - uint32_t flag; - ret = AccessTokenKit::GetPermissionFlag(tokenID, TEST_PERMISSION_NAME_A_MICRO, flag); - ASSERT_EQ(PERMISSION_USER_FIXED, flag); - ASSERT_EQ(RET_SUCCESS, ret); -} - -/** - * @tc.name: GetPermissionFlag002 - * @tc.desc: Get permission flag that tokenID or permission is invalid. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, GetPermissionFlag002, TestSize.Level1) -{ - AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); - - uint32_t flag; - int ret = AccessTokenKit::GetPermissionFlag(tokenID, TEST_PERMISSION_NAME_GAMMA, flag); - ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, ret); - - ret = AccessTokenKit::GetPermissionFlag(tokenID, "", flag); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); - - std::string invalidPerm(INVALID_PERMNAME_LEN, 'a'); - ret = AccessTokenKit::GetPermissionFlag(tokenID, invalidPerm, flag); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); - - ret = AccessTokenKit::GetPermissionFlag(TEST_TOKENID_INVALID, TEST_PERMISSION_NAME_A_MICRO, flag); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); - - AccessTokenKit::DeleteToken(tokenID); - - ret = AccessTokenKit::GetPermissionFlag(tokenID, TEST_PERMISSION_NAME_ALPHA, flag); - ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, ret); -} - -/** - * @tc.name: GetPermissionFlag003 - * @tc.desc: GetPermissionFlag is invoked multiple times. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, GetPermissionFlag003, TestSize.Level0) -{ - AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); - uint32_t flag; - for (int i = 0; i < CYCLE_TIMES; i++) { - int32_t ret = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION_NAME_A_MICRO, PERMISSION_USER_FIXED); - ASSERT_EQ(RET_SUCCESS, ret); - - ret = AccessTokenKit::GetPermissionFlag(tokenID, TEST_PERMISSION_NAME_A_MICRO, flag); - ASSERT_EQ(RET_SUCCESS, ret); - ASSERT_EQ(PERMISSION_USER_FIXED, flag); - } -} - -/** - * @tc.name: GetPermissionFlag004 - * @tc.desc: GetPermissionFlag caller is normal app. - * @tc.type: FUNC - * @tc.require: issueI66BH3 - */ -HWTEST_F(AccessTokenKitTest, GetPermissionFlag004, TestSize.Level0) -{ - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestNormalInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); - - AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - - uint32_t flag; - int ret = AccessTokenKit::GetPermissionFlag(tokenID, TEST_PERMISSION_NAME_A_MICRO, flag); - ASSERT_EQ(ERR_NOT_SYSTEM_APP, ret); - - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); -} - -/** - * @tc.name: GetPermissionFlag005 - * @tc.desc: GetPermissionFlag caller is system app. - * @tc.type: FUNC - * @tc.require: issueI66BH3 - */ -HWTEST_F(AccessTokenKitTest, GetPermissionFlag005, TestSize.Level0) -{ - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestSystemInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); - - AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); - int ret = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION_NAME_A_MICRO, PERMISSION_USER_FIXED); - ASSERT_EQ(RET_SUCCESS, ret); - - uint32_t flag; - ret = AccessTokenKit::GetPermissionFlag(tokenID, TEST_PERMISSION_NAME_A_MICRO, flag); - ASSERT_EQ(PERMISSION_USER_FIXED, flag); - ASSERT_EQ(RET_SUCCESS, ret); - - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); -} - -/** - * @tc.name: GetTokenIDByUserID001 - * @tc.desc: Get token id by user id. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, GetTokenIDByUserID001, TestSize.Level1) -{ - int32_t userID = -1; - std::unordered_set tokenIdList; - int32_t ret = AccessTokenKit::GetTokenIDByUserID(userID, tokenIdList); - EXPECT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); - - userID = 100; - ret = AccessTokenKit::GetTokenIDByUserID(userID, tokenIdList); - EXPECT_EQ(RET_SUCCESS, ret); - EXPECT_NE(static_cast(0), tokenIdList.size()); -} - -/** - * @tc.name: SetPermissionRequestToggleStatus001 - * @tc.desc: Set permission request toggle status that userId, permission or status is invalid. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, SetPermissionRequestToggleStatus001, TestSize.Level1) -{ - int32_t userID = 100; - uint32_t status = PermissionRequestToggleStatus::CLOSED; - - // Permission name is invalid. - int32_t ret = AccessTokenKit::SetPermissionRequestToggleStatus("", status, userID); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); - - // Status is invalid. - status = 2; - ret = AccessTokenKit::SetPermissionRequestToggleStatus(TEST_PERMISSION_NAME_A_MICRO, status, userID); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); - - // UserID is invalid. - userID = -1; - status = PermissionRequestToggleStatus::CLOSED; - ret = AccessTokenKit::SetPermissionRequestToggleStatus(TEST_PERMISSION_NAME_A_MICRO, status, userID); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); -} - -/** - * @tc.name: SetPermissionRequestToggleStatus002 - * @tc.desc: SetPermissionRequestToggleStatus caller is a normal app, not a system app. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, SetPermissionRequestToggleStatus002, TestSize.Level0) -{ - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestNormalInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); - - uint32_t status = PermissionRequestToggleStatus::CLOSED; - int32_t ret = AccessTokenKit::SetPermissionRequestToggleStatus(TEST_PERMISSION_NAME_A_MICRO, status, - g_infoManagerTestNormalInfoParms.userID); - ASSERT_EQ(ERR_NOT_SYSTEM_APP, ret); -} - -/** - * @tc.name: SetPermissionRequestToggleStatus003 - * @tc.desc: SetPermissionRequestToggleStatus caller is a system app without related permissions. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, SetPermissionRequestToggleStatus003, TestSize.Level0) -{ - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestSystemInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); - - int32_t selfUid = getuid(); - setuid(10001); // 10001： UID - - uint32_t status = PermissionRequestToggleStatus::CLOSED; - int32_t ret = AccessTokenKit::SetPermissionRequestToggleStatus(TEST_PERMISSION_NAME_A_MICRO, status, - g_infoManagerTestSystemInfoParms.userID); - ASSERT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, ret); - - status = PermissionRequestToggleStatus::OPEN; - ret = AccessTokenKit::SetPermissionRequestToggleStatus(TEST_PERMISSION_NAME_A_MICRO, status, - g_infoManagerTestSystemInfoParms.userID); - ASSERT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, ret); - - // restore environment - setuid(selfUid); -} - -/** - * @tc.name: SetPermissionRequestToggleStatus004 - * @tc.desc: SetPermissionRequestToggleStatus caller is a system app with related permissions. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, SetPermissionRequestToggleStatus004, TestSize.Level0) -{ - AccessTokenIDEx tokenIdEx = {0}; - - PermissionDef infoManagerTestPermDef = { - .permissionName = "ohos.permission.DISABLE_PERMISSION_DIALOG_TEST", - .bundleName = "accesstoken_test", - .grantMode = 1, - .availableLevel = APL_NORMAL, - .label = "label3", - .labelId = 1, - .description = "open the door", - .descriptionId = 1, - .availableType = MDM - }; - - PermissionStateFull infoManagerTestState = { - .permissionName = "ohos.permission.DISABLE_PERMISSION_DIALOG", - .isGeneral = true, - .resDeviceID = {"local3"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {1} - }; - - HapPolicyParams infoManagerTestPolicyPrams = { - .apl = APL_NORMAL, - .domain = "test.domain3", - .permList = {infoManagerTestPermDef}, - .permStateList = {infoManagerTestState} - }; - - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestSystemInfoParms, infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); - - int32_t selfUid = getuid(); - setuid(10001); // 10001： UID - - uint32_t status = PermissionRequestToggleStatus::CLOSED; - int32_t ret = AccessTokenKit::SetPermissionRequestToggleStatus(TEST_PERMISSION_NAME_A_MICRO, status, - g_infoManagerTestSystemInfoParms.userID); - ASSERT_EQ(RET_SUCCESS, ret); - - status = PermissionRequestToggleStatus::OPEN; - ret = AccessTokenKit::SetPermissionRequestToggleStatus(TEST_PERMISSION_NAME_A_MICRO, status, - g_infoManagerTestSystemInfoParms.userID); - ASSERT_EQ(RET_SUCCESS, ret); - - // restore environment - setuid(selfUid); -} - -/** - * @tc.name: GetPermissionRequestToggleStatus001 - * @tc.desc: Get permission request toggle status that userId, permission is invalid. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, GetPermissionRequestToggleStatus001, TestSize.Level1) -{ - int32_t userID = 100; - uint32_t status; - - // Permission name is invalid. - int32_t ret = AccessTokenKit::GetPermissionRequestToggleStatus("", status, userID); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); - - // UserId is invalid. - userID = -1; - ret = AccessTokenKit::GetPermissionRequestToggleStatus(TEST_PERMISSION_NAME_A_MICRO, status, userID); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); -} - -/** - * @tc.name: GetPermissionRequestToggleStatus002 - * @tc.desc: GetPermissionRequestToggleStatus caller is a normal app, not a system app. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, GetPermissionRequestToggleStatus002, TestSize.Level0) -{ - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestNormalInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); - - uint32_t status; - int32_t ret = AccessTokenKit::GetPermissionRequestToggleStatus(TEST_PERMISSION_NAME_A_MICRO, status, - g_infoManagerTestNormalInfoParms.userID); - ASSERT_EQ(ERR_NOT_SYSTEM_APP, ret); -} - -/** - * @tc.name: GetPermissionRequestToggleStatus003 - * @tc.desc: GetPermissionRequestToggleStatus caller is a system app without related permissions. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, GetPermissionRequestToggleStatus003, TestSize.Level0) -{ - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestSystemInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); - - int32_t selfUid = getuid(); - setuid(10001); // 10001： UID - - uint32_t getStatus; - int32_t ret = AccessTokenKit::GetPermissionRequestToggleStatus(TEST_PERMISSION_NAME_A_MICRO, getStatus, - g_infoManagerTestSystemInfoParms.userID); - ASSERT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, ret); - - // restore environment - setuid(selfUid); -} - -static void AllocAndSetHapToken(void) -{ - AccessTokenIDEx tokenIdEx = {0}; - - PermissionDef infoManagerTestPermDef1 = { - .permissionName = "ohos.permission.DISABLE_PERMISSION_DIALOG_TEST", - .bundleName = "accesstoken_test", - .grantMode = 1, - .availableLevel = APL_NORMAL, - .label = "label3", - .labelId = 1, - .description = "open the door", - .descriptionId = 1, - .availableType = MDM - }; - - PermissionStateFull infoManagerTestState1 = { - .permissionName = "ohos.permission.DISABLE_PERMISSION_DIALOG", - .isGeneral = true, - .resDeviceID = {"local3"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {1} - }; - - PermissionDef infoManagerTestPermDef2 = { - .permissionName = "ohos.permission.GET_SENSITIVE_PERMISSIONS_TEST", - .bundleName = "accesstoken_test", - .grantMode = 1, - .availableLevel = APL_NORMAL, - .label = "label3", - .labelId = 1, - .description = "open the door", - .descriptionId = 1, - .availableType = MDM - }; - - PermissionStateFull infoManagerTestState2 = { - .permissionName = "ohos.permission.GET_SENSITIVE_PERMISSIONS", - .isGeneral = true, - .resDeviceID = {"local3"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {1} - }; - - HapPolicyParams infoManagerTestPolicyPrams = { - .apl = APL_NORMAL, - .domain = "test.domain3", - .permList = {infoManagerTestPermDef1, infoManagerTestPermDef2}, - .permStateList = {infoManagerTestState1, infoManagerTestState2} - }; - - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestSystemInfoParms, infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); -} - -/** - * @tc.name: GetPermissionRequestToggleStatus004 - * @tc.desc: GetPermissionRequestToggleStatus caller is a system app with related permissions. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, GetPermissionRequestToggleStatus004, TestSize.Level0) -{ - AllocAndSetHapToken(); - - int32_t selfUid = getuid(); - setuid(10001); // 10001： UID - - // Set a closed status value. - uint32_t status = PermissionRequestToggleStatus::CLOSED; - int32_t ret = AccessTokenKit::SetPermissionRequestToggleStatus(TEST_PERMISSION_NAME_A_MICRO, status, - g_infoManagerTestSystemInfoParms.userID); - ASSERT_EQ(RET_SUCCESS, ret); - - // Get a closed status value. - uint32_t getStatus; - ret = AccessTokenKit::GetPermissionRequestToggleStatus(TEST_PERMISSION_NAME_A_MICRO, getStatus, - g_infoManagerTestSystemInfoParms.userID); - ASSERT_EQ(RET_SUCCESS, ret); - ASSERT_EQ(PermissionRequestToggleStatus::CLOSED, getStatus); - - // Set a open status value. - status = PermissionRequestToggleStatus::OPEN; - ret = AccessTokenKit::SetPermissionRequestToggleStatus(TEST_PERMISSION_NAME_A_MICRO, status, - g_infoManagerTestSystemInfoParms.userID); - ASSERT_EQ(RET_SUCCESS, ret); - - // Get a open status value. - ret = AccessTokenKit::GetPermissionRequestToggleStatus(TEST_PERMISSION_NAME_A_MICRO, getStatus, - g_infoManagerTestSystemInfoParms.userID); - ASSERT_EQ(RET_SUCCESS, ret); - ASSERT_EQ(PermissionRequestToggleStatus::OPEN, getStatus); - - // restore environment - setuid(selfUid); -} - -/** - * @tc.name: VerifyAccessToken001 - * @tc.desc: Verify user granted permission. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, VerifyAccessToken001, TestSize.Level0) -{ - AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); - int ret = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION_NAME_A_MICRO, PERMISSION_USER_FIXED); - ASSERT_EQ(RET_SUCCESS, ret); - - ret = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_A_MICRO); - ASSERT_EQ(PERMISSION_GRANTED, ret); - ret = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_A_MICRO, false); - ASSERT_EQ(PERMISSION_GRANTED, ret); - - ret = AccessTokenKit::RevokePermission(tokenID, TEST_PERMISSION_NAME_A_MICRO, PERMISSION_USER_FIXED); - ASSERT_EQ(RET_SUCCESS, ret); - - ret = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_A_MICRO); - ASSERT_EQ(PERMISSION_DENIED, ret); - ret = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_A_MICRO, false); - ASSERT_EQ(PERMISSION_DENIED, ret); -} - -/** - * @tc.name: VerifyAccessToken002 - * @tc.desc: Verify system granted permission. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, VerifyAccessToken002, TestSize.Level0) -{ - AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); - int ret = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION_NAME_A_CAMERA, PERMISSION_USER_FIXED); - ASSERT_EQ(RET_SUCCESS, ret); - - ret = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_A_CAMERA); - ASSERT_EQ(PERMISSION_GRANTED, ret); - ret = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_A_CAMERA, false); - ASSERT_EQ(PERMISSION_GRANTED, ret); - - ret = AccessTokenKit::RevokePermission(tokenID, TEST_PERMISSION_NAME_A_CAMERA, PERMISSION_USER_FIXED); - ASSERT_EQ(RET_SUCCESS, ret); - - ret = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_A_CAMERA); - ASSERT_EQ(PERMISSION_DENIED, ret); - ret = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_A_CAMERA, false); - ASSERT_EQ(PERMISSION_DENIED, ret); -} - -/** - * @tc.name: VerifyAccessToken003 - * @tc.desc: Verify permission that tokenID or permission is invalid. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, VerifyAccessToken003, TestSize.Level0) -{ - AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); - int ret = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_GAMMA, false); - ASSERT_EQ(PERMISSION_DENIED, ret); - - ret = AccessTokenKit::VerifyAccessToken(tokenID, ""); - ASSERT_EQ(PERMISSION_DENIED, ret); - ret = AccessTokenKit::VerifyAccessToken(tokenID, "", false); - ASSERT_EQ(PERMISSION_DENIED, ret); - - std::string invalidPerm(INVALID_PERMNAME_LEN, 'a'); - ret = AccessTokenKit::VerifyAccessToken(tokenID, invalidPerm, false); - ASSERT_EQ(PERMISSION_DENIED, ret); - - AccessTokenKit::VerifyAccessToken(TEST_TOKENID_INVALID, TEST_PERMISSION_NAME_A_CAMERA); - ASSERT_EQ(PERMISSION_DENIED, ret); - AccessTokenKit::VerifyAccessToken(TEST_TOKENID_INVALID, TEST_PERMISSION_NAME_A_CAMERA, false); - ASSERT_EQ(PERMISSION_DENIED, ret); - - AccessTokenKit::DeleteToken(tokenID); - - AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_A_CAMERA); - ASSERT_EQ(PERMISSION_DENIED, ret); - AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_A_CAMERA, false); - ASSERT_EQ(PERMISSION_DENIED, ret); -} - -/** - * @tc.name: VerifyAccessTokenWithList001 - * @tc.desc: Verify permission with list. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, VerifyAccessTokenWithList001, TestSize.Level0) -{ - AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); - int ret = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION_NAME_A_MICRO, PERMISSION_USER_FIXED); - ASSERT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION_NAME_A_CAMERA, PERMISSION_USER_FIXED); - ASSERT_EQ(RET_SUCCESS, ret); - - std::vector permissionList; - permissionList.emplace_back(TEST_PERMISSION_NAME_A_MICRO); - permissionList.emplace_back(TEST_PERMISSION_NAME_A_CAMERA); - - std::vector permStateList; - ret = AccessTokenKit::VerifyAccessToken(tokenID, permissionList, permStateList); - for (size_t i = 0; i < permissionList.size(); i++) { - ASSERT_EQ(PERMISSION_GRANTED, permStateList[i]); - } - - permStateList.clear(); - ret = AccessTokenKit::VerifyAccessToken(tokenID, permissionList, permStateList, true); - for (size_t i = 0; i < permissionList.size(); i++) { - ASSERT_EQ(PERMISSION_GRANTED, permStateList[i]); - } - - ret = AccessTokenKit::RevokePermission(tokenID, TEST_PERMISSION_NAME_A_MICRO, PERMISSION_USER_FIXED); - ASSERT_EQ(RET_SUCCESS, ret); - ret = AccessTokenKit::RevokePermission(tokenID, TEST_PERMISSION_NAME_A_CAMERA, PERMISSION_USER_FIXED); - ASSERT_EQ(RET_SUCCESS, ret); - - permStateList.clear(); - ret = AccessTokenKit::VerifyAccessToken(tokenID, permissionList, permStateList); - for (size_t i = 0; i < permissionList.size(); i++) { - ASSERT_EQ(PERMISSION_DENIED, permStateList[i]); - } - - permStateList.clear(); - ret = AccessTokenKit::VerifyAccessToken(tokenID, permissionList, permStateList, true); - for (size_t i = 0; i < permissionList.size(); i++) { - ASSERT_EQ(PERMISSION_DENIED, permStateList[i]); - } -} - -/** - * @tc.name: VerifyAccessTokenWithList002 - * @tc.desc: Verify permission that tokenID or permission is invalid. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, VerifyAccessTokenWithList002, TestSize.Level0) -{ - AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); - - std::vector permissionList; - permissionList.emplace_back(TEST_PERMISSION_NAME_GAMMA); - std::vector permStateList; - int ret = AccessTokenKit::VerifyAccessToken(tokenID, permissionList, permStateList, false); - ASSERT_EQ(RET_SUCCESS, ret); - ASSERT_EQ(PERMISSION_DENIED, permStateList[0]); - - permissionList.clear(); - permissionList.emplace_back(""); - permStateList.clear(); - ret = AccessTokenKit::VerifyAccessToken(tokenID, permissionList, permStateList); - ASSERT_EQ(RET_SUCCESS, ret); - ASSERT_EQ(PERMISSION_DENIED, permStateList[0]); - - std::string invalidPerm(INVALID_PERMNAME_LEN, 'a'); - permissionList.clear(); - permissionList.emplace_back(invalidPerm); - permStateList.clear(); - ret = AccessTokenKit::VerifyAccessToken(tokenID, permissionList, permStateList); - ASSERT_EQ(RET_SUCCESS, ret); - ASSERT_EQ(PERMISSION_DENIED, permStateList[0]); - - permissionList.clear(); - permissionList.emplace_back(TEST_PERMISSION_NAME_A_MICRO); - permissionList.emplace_back(TEST_PERMISSION_NAME_A_CAMERA); - permissionList.emplace_back(invalidPerm); - permStateList.clear(); - ret = AccessTokenKit::VerifyAccessToken(TEST_TOKENID_INVALID, permissionList, permStateList); - ASSERT_EQ(RET_SUCCESS, ret); - ASSERT_EQ(PERMISSION_DENIED, permStateList[0]); - ASSERT_EQ(PERMISSION_DENIED, permStateList[1]); - ASSERT_EQ(PERMISSION_DENIED, permStateList[2]); -} - -/** - * @tc.name: GrantPermission001 - * @tc.desc: Grant permission that has ohos.permission.GRANT_SENSITIVE_PERMISSIONS - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, GrantPermission001, TestSize.Level0) -{ - AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); - int ret = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION_NAME_A_MICRO, PERMISSION_USER_FIXED); - ASSERT_EQ(RET_SUCCESS, ret); - - ret = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_A_MICRO, false); - ASSERT_EQ(PERMISSION_GRANTED, ret); - - ret = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION_NAME_A_CAMERA, PERMISSION_USER_FIXED); - ASSERT_EQ(RET_SUCCESS, ret); - - ret = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_A_MICRO, false); - ASSERT_EQ(PERMISSION_GRANTED, ret); -} - -/** - * @tc.name: GrantPermission002 - * @tc.desc: Grant permission that tokenID or permission is invalid. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, GrantPermission002, TestSize.Level0) -{ - AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); - - int ret = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION_NAME_GAMMA, PERMISSION_USER_FIXED); - ASSERT_EQ(ERR_PERMISSION_NOT_EXIST, ret); - - ret = AccessTokenKit::GrantPermission(tokenID, "", PERMISSION_USER_FIXED); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); - - std::string invalidPerm(INVALID_PERMNAME_LEN, 'a'); - ret = AccessTokenKit::GrantPermission(tokenID, invalidPerm, PERMISSION_USER_FIXED); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); - - ret = AccessTokenKit::GrantPermission(TEST_TOKENID_INVALID, TEST_PERMISSION_NAME_BETA, PERMISSION_USER_FIXED); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); - - AccessTokenKit::DeleteToken(tokenID); - - ret = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION_NAME_BETA, PERMISSION_USER_FIXED); - ASSERT_EQ(ERR_PERMISSION_NOT_EXIST, ret); -} - -/** - * @tc.name: GrantPermission003 - * @tc.desc: GrantPermission is invoked multiple times. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, GrantPermission003, TestSize.Level0) -{ - AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); - uint32_t flag; - for (int i = 0; i < CYCLE_TIMES; i++) { - int32_t ret = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION_NAME_A_MICRO, PERMISSION_USER_FIXED); - ASSERT_EQ(RET_SUCCESS, ret); - - ret = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_A_MICRO, false); - ASSERT_EQ(PERMISSION_GRANTED, ret); - - ret = AccessTokenKit::GetPermissionFlag(tokenID, TEST_PERMISSION_NAME_A_MICRO, flag); - ASSERT_EQ(PERMISSION_USER_FIXED, flag); - ASSERT_EQ(RET_SUCCESS, ret); - } -} - -/** - * @tc.name: GrantPermission004 - * @tc.desc: GrantPermission function abnormal branch - * @tc.type: FUNC - * @tc.require:Issue I5RJBB - */ -HWTEST_F(AccessTokenKitTest, GrantPermission004, TestSize.Level0) -{ - AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); - int32_t invalidFlag = -1; - int32_t ret = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION_NAME_A_MICRO, invalidFlag); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); -} - -/** - * @tc.name: GrantPermission005 - * @tc.desc: GrantPermission caller is normal app. - * @tc.type: FUNC - * @tc.require: issueI66BH3 - */ -HWTEST_F(AccessTokenKitTest, GrantPermission005, TestSize.Level0) -{ - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestNormalInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); - - AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); - int ret = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION_NAME_A_MICRO, PERMISSION_USER_FIXED); - ASSERT_EQ(ERR_NOT_SYSTEM_APP, ret); -} - -/** - * @tc.name: GrantPermission006 - * @tc.desc: GrantPermission caller is system app. - * @tc.type: FUNC - * @tc.require: issueI66BH3 - */ -HWTEST_F(AccessTokenKitTest, GrantPermission006, TestSize.Level0) -{ - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestSystemInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); - - AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); - int ret = AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION_NAME_A_MICRO, PERMISSION_USER_FIXED); - ASSERT_EQ(RET_SUCCESS, ret); - - ret = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_A_MICRO, false); - ASSERT_EQ(PERMISSION_GRANTED, ret); - - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); -} - -/** - * @tc.name: RevokePermission001 - * @tc.desc: Revoke permission that has ohos.permission.REVOKE_SENSITIVE_PERMISSIONS - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, RevokePermission001, TestSize.Level0) -{ - AccessTokenID tokenId = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenId); - int ret = AccessTokenKit::RevokePermission(tokenId, TEST_PERMISSION_NAME_A_MICRO, PERMISSION_USER_FIXED); - ASSERT_EQ(RET_SUCCESS, ret); - - ret = AccessTokenKit::VerifyAccessToken(tokenId, TEST_PERMISSION_NAME_A_MICRO, false); - ASSERT_EQ(PERMISSION_DENIED, ret); - - ret = AccessTokenKit::RevokePermission(tokenId, TEST_PERMISSION_NAME_A_CAMERA, PERMISSION_USER_FIXED); - ASSERT_EQ(RET_SUCCESS, ret); - - ret = AccessTokenKit::VerifyAccessToken(tokenId, TEST_PERMISSION_NAME_A_MICRO, false); - ASSERT_EQ(PERMISSION_DENIED, ret); -} - -/** - * @tc.name: RevokePermission002 - * @tc.desc: Revoke permission that tokenID or permission is invalid. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, RevokePermission002, TestSize.Level0) -{ - AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); - - int ret = AccessTokenKit::RevokePermission(tokenID, TEST_PERMISSION_NAME_GAMMA, PERMISSION_USER_FIXED); - ASSERT_EQ(ERR_PERMISSION_NOT_EXIST, ret); - - ret = AccessTokenKit::RevokePermission(tokenID, "", PERMISSION_USER_FIXED); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); - - std::string invalidPerm(INVALID_PERMNAME_LEN, 'a'); - ret = AccessTokenKit::RevokePermission(tokenID, invalidPerm, PERMISSION_USER_FIXED); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); - - ret = AccessTokenKit::RevokePermission(TEST_TOKENID_INVALID, TEST_PERMISSION_NAME_BETA, PERMISSION_USER_FIXED); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); - - AccessTokenKit::DeleteToken(tokenID); - - ret = AccessTokenKit::RevokePermission(tokenID, TEST_PERMISSION_NAME_BETA, PERMISSION_USER_FIXED); - ASSERT_EQ(ERR_PERMISSION_NOT_EXIST, ret); -} - -/** - * @tc.name: RevokePermission003 - * @tc.desc: RevokePermission is invoked multiple times. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, RevokePermission003, TestSize.Level0) -{ - AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); - uint32_t flag; - for (int i = 0; i < CYCLE_TIMES; i++) { - int32_t ret = AccessTokenKit::RevokePermission(tokenID, TEST_PERMISSION_NAME_A_MICRO, PERMISSION_USER_FIXED); - ASSERT_EQ(RET_SUCCESS, ret); - - ret = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_A_MICRO, false); - ASSERT_EQ(PERMISSION_DENIED, ret); - - ret = AccessTokenKit::GetPermissionFlag(tokenID, TEST_PERMISSION_NAME_A_MICRO, flag); - ASSERT_EQ(PERMISSION_USER_FIXED, flag); - ASSERT_EQ(RET_SUCCESS, ret); - } -} - -/** - * @tc.name: RevokePermission004 - * @tc.desc: Revoke permission abnormal branch. - * @tc.type: FUNC - * @tc.require:Issue I5RJBB - */ -HWTEST_F(AccessTokenKitTest, RevokePermission004, TestSize.Level0) -{ - AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); - int invalidFlag = -1; - int32_t ret = AccessTokenKit::RevokePermission(tokenID, TEST_PERMISSION_NAME_A_MICRO, invalidFlag); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); -} - -/** - * @tc.name: RevokePermission005 - * @tc.desc: Revoke permission caller is normal app. - * @tc.type: FUNC - * @tc.require: issueI66BH3 - */ -HWTEST_F(AccessTokenKitTest, RevokePermission005, TestSize.Level0) -{ - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestNormalInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); - - AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); - int ret = AccessTokenKit::RevokePermission(tokenID, TEST_PERMISSION_NAME_A_MICRO, PERMISSION_USER_FIXED); - ASSERT_EQ(ERR_NOT_SYSTEM_APP, ret); - - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); -} - -/** - * @tc.name: RevokePermission006 - * @tc.desc: Revoke permission caller is system app. - * @tc.type: FUNC - * @tc.require: issueI66BH3 - */ -HWTEST_F(AccessTokenKitTest, RevokePermission006, TestSize.Level0) -{ - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestSystemInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); - - AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); - int ret = AccessTokenKit::RevokePermission(tokenID, TEST_PERMISSION_NAME_A_MICRO, PERMISSION_USER_FIXED); - ASSERT_EQ(RET_SUCCESS, ret); - - ret = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_A_MICRO, false); - ASSERT_EQ(PERMISSION_DENIED, ret); - - ret = AccessTokenKit::RevokePermission(tokenID, TEST_PERMISSION_NAME_A_CAMERA, PERMISSION_USER_FIXED); - ASSERT_EQ(RET_SUCCESS, ret); - - ret = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_A_MICRO, false); - ASSERT_EQ(PERMISSION_DENIED, ret); - - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); -} - -/** - * @tc.name: ClearUserGrantedPermissionState001 - * @tc.desc: Clear user/system granted permission after ClearUserGrantedPermissionState has been invoked. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, ClearUserGrantedPermissionState001, TestSize.Level0) -{ - AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); - int ret = AccessTokenKit::ClearUserGrantedPermissionState(tokenID); - ASSERT_EQ(RET_SUCCESS, ret); - - ret = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_A_MICRO, false); - ASSERT_EQ(PERMISSION_DENIED, ret); - - ret = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_A_CAMERA, false); - ASSERT_EQ(PERMISSION_DENIED, ret); -} - -/** - * @tc.name: ClearUserGrantedPermissionState002 - * @tc.desc: Clear user/system granted permission that tokenID or permission is invalid. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, ClearUserGrantedPermissionState002, TestSize.Level0) -{ - AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); - - int ret = AccessTokenKit::ClearUserGrantedPermissionState(TEST_TOKENID_INVALID); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); - - AccessTokenKit::DeleteToken(tokenID); - - ret = AccessTokenKit::ClearUserGrantedPermissionState(tokenID); - ASSERT_EQ(RET_SUCCESS, ret); -} - -/** - * @tc.name: ClearUserGrantedPermissionState003 - * @tc.desc: ClearUserGrantedPermissionState is invoked multiple times. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, ClearUserGrantedPermissionState003, TestSize.Level0) -{ - AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); - for (int i = 0; i < CYCLE_TIMES; i++) { - int32_t ret = AccessTokenKit::ClearUserGrantedPermissionState(tokenID); - ASSERT_EQ(RET_SUCCESS, ret); - - ret = AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_A_MICRO, false); - ASSERT_EQ(PERMISSION_DENIED, ret); - } -} - -/** - * @tc.name: ClearUserGrantedPermissionState004 - * @tc.desc: Clear user/system granted permission after ClearUserGrantedPermissionState has been invoked. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, ClearUserGrantedPermissionState004, TestSize.Level0) -{ - AccessTokenIDEx tokenIdEx = {0}; - OHOS::Security::AccessToken::PermissionStateFull infoManagerTestState1 = { - .permissionName = "ohos.permission.CAMERA", - .isGeneral = true, - .resDeviceID = {"local"}, - .grantStatus = {OHOS::Security::AccessToken::PermissionState::PERMISSION_DENIED}, - .grantFlags = {PERMISSION_GRANTED_BY_POLICY | PERMISSION_DEFAULT_FLAG} - }; - OHOS::Security::AccessToken::PermissionStateFull infoManagerTestState2 = { - .permissionName = "ohos.permission.SEND_MESSAGES", - .isGeneral = true, - .resDeviceID = {"local"}, - .grantStatus = {OHOS::Security::AccessToken::PermissionState::PERMISSION_DENIED}, - .grantFlags = {PERMISSION_GRANTED_BY_POLICY | PERMISSION_USER_FIXED} - }; - OHOS::Security::AccessToken::PermissionStateFull infoManagerTestState3 = { - .permissionName = "ohos.permission.RECEIVE_SMS", - .isGeneral = true, - .resDeviceID = {"local"}, - .grantStatus = {OHOS::Security::AccessToken::PermissionState::PERMISSION_GRANTED}, - .grantFlags = {PERMISSION_USER_FIXED} - }; - OHOS::Security::AccessToken::HapPolicyParams infoManagerTestPolicyPrams = { - .apl = OHOS::Security::AccessToken::ATokenAplEnum::APL_NORMAL, - .domain = "test.domain", - .permList = {g_infoManagerTestPermDef1}, - .permStateList = {infoManagerTestState1, infoManagerTestState2, infoManagerTestState3} - }; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams); - AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; - ASSERT_NE(INVALID_TOKENID, tokenID); - - int ret = AccessTokenKit::ClearUserGrantedPermissionState(tokenID); - ASSERT_EQ(RET_SUCCESS, ret); - - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.CAMERA", false); - ASSERT_EQ(PERMISSION_GRANTED, ret); - - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.SEND_MESSAGES", false); - ASSERT_EQ(PERMISSION_GRANTED, ret); - - ret = AccessTokenKit::VerifyAccessToken(tokenID, "ohos.permission.RECEIVE_SMS", false); - ASSERT_EQ(PERMISSION_DENIED, ret); - - ret = AccessTokenKit::DeleteToken(tokenID); - ASSERT_EQ(RET_SUCCESS, ret); -} - -/** - * @tc.name: GetTokenType001 - * @tc.desc: get the token type. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, GetTokenType001, TestSize.Level0) -{ - AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); - int ret = AccessTokenKit::GetTokenType(tokenID); - ASSERT_EQ(TOKEN_HAP, ret); - DeleteTestToken(); -} - -/** - * @tc.name: GetTokenType002 - * @tc.desc: get the token type abnormal branch. - * @tc.type: FUNC - * @tc.require Issue I5RJBB - */ -HWTEST_F(AccessTokenKitTest, GetTokenType002, TestSize.Level0) -{ - AccessTokenID tokenID = 0; - int32_t ret = AccessTokenKit::GetTokenType(tokenID); - ASSERT_EQ(TOKEN_INVALID, ret); -} - -/** - * @tc.name: GetHapDlpFlag001 - * @tc.desc: GetHapDlpFlag function abnormal branch. - * @tc.type: FUNC - * @tc.require Issue Number:I5RJBB - */ -HWTEST_F(AccessTokenKitTest, GetHapDlpFlag001, TestSize.Level0) -{ - AccessTokenID tokenID = 0; - int32_t ret = AccessTokenKit::GetHapDlpFlag(tokenID); - ASSERT_EQ(INVALID_DLP_TOKEN_FLAG, ret); -} - -/** - * @tc.name: GetHapTokenInfo001 - * @tc.desc: get the token info and verify. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, GetHapTokenInfo001, TestSize.Level0) -{ - HapTokenInfo hapTokenInfoRes; - AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - int ret = AccessTokenKit::GetHapTokenInfo(tokenID, hapTokenInfoRes); - ASSERT_EQ(RET_SUCCESS, ret); - - ASSERT_EQ(hapTokenInfoRes.userID, TEST_USER_ID); - ASSERT_EQ(hapTokenInfoRes.tokenID, tokenID); - ASSERT_EQ(hapTokenInfoRes.tokenAttr, static_cast(0)); - ASSERT_EQ(hapTokenInfoRes.instIndex, 0); - - ASSERT_EQ(hapTokenInfoRes.bundleName, TEST_BUNDLE_NAME); -} - -/** - * @tc.name: GetHapTokenInfo002 - * @tc.desc: try to get the token info with invalid tokenId. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, GetHapTokenInfo002, TestSize.Level0) -{ - HapTokenInfo hapTokenInfoRes; - int ret = AccessTokenKit::GetHapTokenInfo(TEST_TOKENID_INVALID, hapTokenInfoRes); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); -} - -/** - * @tc.name: DeleteToken002 - * @tc.desc: Delete invalid tokenID. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, DeleteToken002, TestSize.Level1) -{ - int ret = AccessTokenKit::DeleteToken(TEST_TOKENID_INVALID); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); -} - -/** - * @tc.name: DeleteToken002 - * @tc.desc: Delete invalid tokenID. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, DeleteToken003, TestSize.Level1) -{ - HapTokenInfo hapTokenInfoRes; - AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - - int ret = AccessTokenKit::GetHapTokenInfo(tokenID, hapTokenInfoRes); - ASSERT_EQ(RET_SUCCESS, ret); - - ret = AccessTokenKit::DeleteToken(tokenID); - ASSERT_EQ(RET_SUCCESS, ret); - - ret = AccessTokenKit::GetHapTokenInfo(tokenID, hapTokenInfoRes); - ASSERT_EQ(AccessTokenError::ERR_TOKENID_NOT_EXIST, ret); -} - -/** - * @tc.name: DeleteToken004 - * @tc.desc: alloc a tokenId successfully, delete it successfully the first time and fail to delete it again. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, DeleteToken004, TestSize.Level1) -{ - AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); - GTEST_LOG_(INFO) << "tokenID :" << tokenID; - - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); - ASSERT_NE(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); -} - -/** - * @tc.name: GetHapTokenID001 - * @tc.desc: get hap tokenid. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, GetHapTokenID001, TestSize.Level1) -{ - HapTokenInfo hapTokenInfoRes; - AccessTokenID tokenID; - tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - - int ret = AccessTokenKit::GetHapTokenInfo(tokenID, hapTokenInfoRes); - ASSERT_EQ(RET_SUCCESS, ret); - ASSERT_EQ(hapTokenInfoRes.bundleName, TEST_BUNDLE_NAME); -} - -/** - * @tc.name: GetHapTokenID002 - * @tc.desc: cannot get hap tokenid with invalid userId. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, GetHapTokenID002, TestSize.Level1) -{ - AccessTokenID tokenID; - tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID_INVALID, TEST_BUNDLE_NAME, 0); - ASSERT_EQ(INVALID_TOKENID, tokenID); -} - -/** - * @tc.name: GetHapTokenID003 - * @tc.desc: cannot get hap tokenid with invalid bundlename. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, GetHapTokenID003, TestSize.Level1) -{ - AccessTokenID tokenID; - tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, "invalid bundlename", 0); - ASSERT_EQ(INVALID_TOKENID, tokenID); -} - -/** - * @tc.name: GetHapTokenID004 - * @tc.desc: cannot get hap tokenid with invalid bundlename. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, GetHapTokenID004, TestSize.Level1) -{ - AccessTokenID tokenID; - tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0xffff); - ASSERT_EQ(INVALID_TOKENID, tokenID); -} - -/** - * @tc.name: GetHapTokenIDEx001 - * @tc.desc: get hap tokenid. - * @tc.type: FUNC - * @tc.require: issueI60F1M - */ -HWTEST_F(AccessTokenKitTest, GetHapTokenIDEx001, TestSize.Level1) -{ - AccessTokenIDEx tokenIdEx; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestSystemInfoParms, g_infoManagerTestPolicyPrams); - - AccessTokenIDEx tokenIdEx1; - tokenIdEx1 = AccessTokenKit::GetHapTokenIDEx(g_infoManagerTestSystemInfoParms.userID, - g_infoManagerTestSystemInfoParms.bundleName, - g_infoManagerTestSystemInfoParms.instIndex); - - ASSERT_EQ(tokenIdEx.tokenIDEx, tokenIdEx1.tokenIDEx); - HapTokenInfo hapTokenInfoRes; - AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; - int ret = AccessTokenKit::GetHapTokenInfo(tokenID, hapTokenInfoRes); - ASSERT_EQ(RET_SUCCESS, ret); - ASSERT_EQ(hapTokenInfoRes.bundleName, g_infoManagerTestSystemInfoParms.bundleName); - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); -} - -/** - * @tc.name: GetHapTokenIDEx002 - * @tc.desc: cannot get hap tokenid with invalid userId. - * @tc.type: FUNC - * @tc.require: issueI60F1M - */ -HWTEST_F(AccessTokenKitTest, GetHapTokenIDEx002, TestSize.Level1) -{ - AccessTokenIDEx tokenIdEx; - tokenIdEx = AccessTokenKit::GetHapTokenIDEx(TEST_USER_ID_INVALID, TEST_BUNDLE_NAME, 0); - ASSERT_EQ(INVALID_TOKENID, tokenIdEx.tokenIDEx); -} - -/** - * @tc.name: GetHapTokenIDEx003 - * @tc.desc: cannot get hap tokenid with invalid bundlename. - * @tc.type: FUNC - * @tc.require: issueI60F1M - */ -HWTEST_F(AccessTokenKitTest, GetHapTokenIDEx003, TestSize.Level1) -{ - AccessTokenIDEx tokenIdEx; - tokenIdEx = AccessTokenKit::GetHapTokenIDEx(TEST_USER_ID, "invalid bundlename", 0); - ASSERT_EQ(INVALID_TOKENID, tokenIdEx.tokenIDEx); -} - -/** - * @tc.name: GetHapTokenIDEx004 - * @tc.desc: cannot get hap tokenid with invalid instIndex. - * @tc.type: FUNC - * @tc.require: issueI60F1M - */ -HWTEST_F(AccessTokenKitTest, GetHapTokenIDEx004, TestSize.Level1) -{ - AccessTokenIDEx tokenIdEx; - tokenIdEx = AccessTokenKit::GetHapTokenIDEx(TEST_USER_ID, TEST_BUNDLE_NAME, 0xffff); - ASSERT_EQ(INVALID_TOKENID, tokenIdEx.tokenIDEx); -} - -/** - * @tc.name: ReloadNativeTokenInfo001 - * @tc.desc: cannot get hap tokenid with invalid bundlename. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, ReloadNativeTokenInfo001, TestSize.Level1) -{ - int32_t ret = AccessTokenKit::ReloadNativeTokenInfo(); - ASSERT_EQ(RET_SUCCESS, ret); -} - -/** - * @tc.name: ReloadNativeTokenInfo002 - * @tc.desc: ReloadNativeTokenInfo with same bundlename twicely. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, ReloadNativeTokenInfo002, TestSize.Level1) -{ - const char **perms = new const char *[1]; - perms[0] = "ohos.permission.MANAGE_HAP_TOKENID"; - uint64_t token1 = GetNativeTokenTest("TestCase_core", perms, 1); - ASSERT_NE(INVALID_TOKENID, token1); - ASSERT_EQ( - PERMISSION_GRANTED, AccessTokenKit::VerifyAccessToken(token1, "ohos.permission.MANAGE_HAP_TOKENID", false)); - - uint64_t token2 = GetNativeTokenTest("TestCase_core", nullptr, 0); - ASSERT_NE(INVALID_TOKENID, token2); - - ASSERT_EQ(token1, token2); - ASSERT_EQ( - PERMISSION_DENIED, AccessTokenKit::VerifyAccessToken(token2, "ohos.permission.MANAGE_HAP_TOKENID", false)); - - uint64_t token3 = GetNativeTokenTest("TestCase_core", perms, 1); - ASSERT_NE(INVALID_TOKENID, token3); - - ASSERT_EQ(token1, token3); - ASSERT_EQ( - PERMISSION_GRANTED, AccessTokenKit::VerifyAccessToken(token3, "ohos.permission.MANAGE_HAP_TOKENID", false)); -} - -/** - * @tc.name: GetNativeTokenId001 - * @tc.desc: cannot get native tokenid with invalid processName. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, GetNativeTokenId001, TestSize.Level1) -{ - std::string processName = ""; - ASSERT_EQ(INVALID_TOKENID, AccessTokenKit::GetNativeTokenId(processName)); - - processName = "invalid processName"; - ASSERT_EQ(INVALID_TOKENID, AccessTokenKit::GetNativeTokenId(processName)); -} - -/** - * @tc.name: GetNativeTokenId002 - * @tc.desc: get native tokenid with processName. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, GetNativeTokenId002, TestSize.Level1) -{ - std::string processName = "hdcd"; - AccessTokenID tokenID = AccessTokenKit::GetNativeTokenId(processName); - ASSERT_NE(INVALID_TOKENID, tokenID); - - NativeTokenInfo tokenInfo; - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GetNativeTokenInfo(tokenID, tokenInfo)); - ASSERT_EQ(true, tokenInfo.processName == processName); -} - -/** - * @tc.name: GetNativeTokenId003 - * @tc.desc: get native tokenid with hap. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, GetNativeTokenId003, TestSize.Level1) -{ - std::string processName = "hdcd"; - AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); - ASSERT_EQ(0, SetSelfTokenID(tokenID)); - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::ReloadNativeTokenInfo()); - - tokenID = AccessTokenKit::GetNativeTokenId(processName); - ASSERT_NE(INVALID_TOKENID, tokenID); - - NativeTokenInfo tokenInfo; - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GetNativeTokenInfo(tokenID, tokenInfo)); - ASSERT_EQ(true, tokenInfo.processName == processName); - - ASSERT_EQ(0, SetSelfTokenID(selfTokenId_)); -} - -/** - * @tc.name: GetNativeTokenId004 - * @tc.desc: get native tokenid with hap. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, GetNativeTokenId004, TestSize.Level1) -{ - std::string processName = "hdcd"; - AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); - ASSERT_EQ(RET_SUCCESS, SetSelfTokenID(tokenID)); - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::ReloadNativeTokenInfo()); - - int32_t selfUid = getuid(); - setuid(10001); // 10001： UID - - ASSERT_EQ(INVALID_TOKENID, AccessTokenKit::GetNativeTokenId(processName)); - - // restore environment - setuid(selfUid); - ASSERT_EQ(RET_SUCCESS, SetSelfTokenID(selfTokenId_)); -} - -/** - * @tc.name: AllocHapToken001 - * @tc.desc: alloc a tokenId successfully, delete it successfully the first time and fail to delete it again. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, AllocHapToken001, TestSize.Level1) -{ - AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); - GTEST_LOG_(INFO) << "tokenID :" << tokenID; - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); - ASSERT_NE(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); -} - -/** - * @tc.name: AllocHapToken002 - * @tc.desc: alloc a tokenId successfully, - * and fail to alloc it with the same info and policy again. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, AllocHapToken002, TestSize.Level1) -{ - AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); - GTEST_LOG_(INFO) << "tokenID :" << tokenID; - ASSERT_NE(INVALID_TOKENID, tokenID); - - AccessTokenID tokenID1 = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenID1); - ASSERT_NE(tokenID, tokenID1); - ASSERT_NE(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID1)); -} - -/** - * @tc.name: AllocHapToken003 - * @tc.desc: cannot alloc a tokenId with invalid bundlename. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, AllocHapToken003, TestSize.Level1) -{ - std::string invalidBundleName (INVALID_BUNDLENAME_LEN, 'x'); - std::string bundle = g_infoManagerTestInfoParms.bundleName; - - GTEST_LOG_(INFO) << "get hap token info:" << invalidBundleName.length(); - - g_infoManagerTestInfoParms.bundleName = invalidBundleName; - AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_EQ(INVALID_TOKENID, tokenID); - - tokenID = GetAccessTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); - ASSERT_EQ(INVALID_TOKENID, tokenID); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, AccessTokenKit::DeleteToken(tokenID)); - - g_infoManagerTestInfoParms.bundleName = bundle; -} - -/** - * @tc.name: AllocHapToken004 - * @tc.desc: cannot alloc a tokenId with invalid apl. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, AllocHapToken004, TestSize.Level1) -{ - g_infoManagerTestPolicyPrams.apl = (ATokenAplEnum)5; - AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_EQ(INVALID_TOKENID, tokenID); - - tokenID = GetAccessTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); - ASSERT_EQ(INVALID_TOKENID, tokenID); - - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, AccessTokenKit::DeleteToken(tokenID)); -} - -/** - * @tc.name: AllocHapToken005 - * @tc.desc: can alloc a tokenId when bundlename in permdef is different with bundlename in info. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, AllocHapToken005, TestSize.Level1) -{ - g_infoManagerTestPolicyPrams.permList[INDEX_ONE].bundleName = "invalid_bundleName"; - g_infoManagerTestPolicyPrams.permList[INDEX_ONE].permissionName = "ohos.permission.testtmp01"; - g_infoManagerTestPolicyPrams.permList[INDEX_ONE].availableType = MDM; - AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenID); - - PermissionDef permDefResult; - ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, AccessTokenKit::GetDefPermission( - g_infoManagerTestPolicyPrams.permList[INDEX_ONE].permissionName, permDefResult)); -} - -/** - * @tc.name: AllocHapToken006 - * @tc.desc: can alloc a tokenId with a invalid permList permissionName. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, AllocHapToken006, TestSize.Level1) -{ - const std::string invalidPermissionName (INVALID_PERMNAME_LEN, 'x'); - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = invalidPermissionName; - AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenID); - - PermissionDef permDefResultBeta; - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, AccessTokenKit::GetDefPermission( - invalidPermissionName, permDefResultBeta)); - ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, AccessTokenKit::GetDefPermission( - g_infoManagerTestPolicyPrams.permList[INDEX_ONE].permissionName, permDefResultBeta)); -} - -/** - * @tc.name: AllocHapToken007 - * @tc.desc: can alloc a tokenId with invalid permdef. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, AllocHapToken007, TestSize.Level1) -{ - const std::string invalidBundleName (INVALID_BUNDLENAME_LEN, 'x'); - - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = "ohos.permission.testtmp02"; - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].bundleName = invalidBundleName; - AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenID); - - PermissionDef permDefResultBeta; - ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, AccessTokenKit::GetDefPermission( - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName, permDefResultBeta)); - ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, AccessTokenKit::GetDefPermission( - g_infoManagerTestPolicyPrams.permList[INDEX_ONE].permissionName, permDefResultBeta)); -} - -/** - * @tc.name: AllocHapToken008 - * @tc.desc: can alloc a tokenId with invalid permdef. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, AllocHapToken008, TestSize.Level1) -{ - const std::string invalidLabel (INVALID_LABEL_LEN, 'x'); - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = "ohos.permission.testtmp03"; - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].label = invalidLabel; - AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenID); - - PermissionDef permDefResultBeta; - ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, AccessTokenKit::GetDefPermission( - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName, permDefResultBeta)); - ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, AccessTokenKit::GetDefPermission( - g_infoManagerTestPolicyPrams.permList[INDEX_ONE].permissionName, permDefResultBeta)); -} - -/** - * @tc.name: AllocHapToken009 - * @tc.desc: can alloc a tokenId with invalid permdef. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, AllocHapToken009, TestSize.Level1) -{ - const std::string invalidDescription (INVALID_DESCRIPTION_LEN, 'x'); - - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = "ohos.permission.testtmp04"; - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].description = invalidDescription; - AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenID); - - PermissionDef permDefResultBeta; - ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, AccessTokenKit::GetDefPermission( - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName, permDefResultBeta)); - ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, AccessTokenKit::GetDefPermission( - g_infoManagerTestPolicyPrams.permList[INDEX_ONE].permissionName, permDefResultBeta)); -} - -static bool ExistInVector(vector array, unsigned int value) -{ - vector::iterator it; - it = find(array.begin(), array.end(), value); - if (it != array.end()) { - return true; - } else { - return false; - } -} - -/** - * @tc.name: AllocHapToken010 - * @tc.desc: alloc and delete in a loop. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, AllocHapToken010, TestSize.Level1) -{ - int ret; - bool exist = false; - int allocFlag = 0; - int deleteFlag = 0; - - DeleteTestToken(); - vector obj; - for (int i = 0; i < CYCLE_TIMES; i++) { - AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); - - exist = ExistInVector(obj, tokenID); - if (exist) { - allocFlag = 1; - } - obj.push_back(tokenID); - - ret = AccessTokenKit::DeleteToken(tokenID); - if (RET_SUCCESS != ret) { - deleteFlag = 1; - } - } - ASSERT_EQ(allocFlag, 0); - ASSERT_EQ(deleteFlag, 0); -} - -/** - * @tc.name: AllocHapToken011 - * @tc.desc: cannot alloc a tokenId with invalid appIDDesc. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, AllocHapToken011, TestSize.Level1) -{ - std::string invalidAppIDDesc (INVALID_APPIDDESC_LEN, 'x'); - std::string backup = g_infoManagerTestInfoParms.appIDDesc; - - DeleteTestToken(); - - g_infoManagerTestInfoParms.appIDDesc = invalidAppIDDesc; - AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_EQ(INVALID_TOKENID, tokenID); - g_infoManagerTestInfoParms.appIDDesc = backup; -} - -/** - * @tc.name: AllocHapToken012 - * @tc.desc: cannot alloc a tokenId with invalid bundleName. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, AllocHapToken012, TestSize.Level1) -{ - std::string backup = g_infoManagerTestInfoParms.bundleName; - - g_infoManagerTestInfoParms.bundleName = ""; - AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_EQ(INVALID_TOKENID, tokenID); - g_infoManagerTestInfoParms.bundleName = backup; -} - -/** - * @tc.name: AllocHapToken013 - * @tc.desc: cannot alloc a tokenId with invalid appIDDesc. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, AllocHapToken013, TestSize.Level1) -{ - std::string backup = g_infoManagerTestInfoParms.appIDDesc; - - g_infoManagerTestInfoParms.appIDDesc = ""; - AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_EQ(INVALID_TOKENID, tokenID); - g_infoManagerTestInfoParms.appIDDesc = backup; -} - -/** - * @tc.name: AllocHapToken015 - * @tc.desc: can alloc a tokenId with permList bundleName as "". - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, AllocHapToken015, TestSize.Level1) -{ - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].bundleName = ""; - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = "ohos.permission.testtmp05"; - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].label = ""; - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].description = ""; - AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); - - PermissionDef permDefResultBeta; - ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, AccessTokenKit::GetDefPermission( - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName, permDefResultBeta)); - ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, AccessTokenKit::GetDefPermission( - g_infoManagerTestPolicyPrams.permList[INDEX_ONE].permissionName, permDefResultBeta)); -} - -void AccessTokenKitTest::GetDlpFlagTest(HapInfoParams info, HapPolicyParams policy, int flag) -{ - int32_t ret; - HapTokenInfo hapTokenInfoRes; - uint32_t tokenID = GetAccessTokenID(info.userID, info.bundleName, 2); - if (tokenID != 0) { - ret = AccessTokenKit::DeleteToken(tokenID); - } - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(info, policy); - EXPECT_NE(INVALID_TOKENID, tokenIdEx.tokenIdExStruct.tokenID); - ret = AccessTokenKit::GetHapTokenInfo(tokenIdEx.tokenIdExStruct.tokenID, hapTokenInfoRes); - EXPECT_EQ(ret, RET_SUCCESS); - EXPECT_EQ(hapTokenInfoRes.dlpType, flag); - if (flag == DLP_COMMON) { - EXPECT_EQ(AccessTokenKit::GetHapDlpFlag(tokenIdEx.tokenIdExStruct.tokenID), 0); - } else { - EXPECT_EQ(AccessTokenKit::GetHapDlpFlag(tokenIdEx.tokenIdExStruct.tokenID), 1); - } - ret = AccessTokenKit::DeleteToken(tokenIdEx.tokenIdExStruct.tokenID); - EXPECT_EQ(RET_SUCCESS, ret); - GTEST_LOG_(INFO) << "tokenID :" << tokenIdEx.tokenIdExStruct.tokenID; - ret = AccessTokenKit::GetHapTokenInfo(tokenIdEx.tokenIdExStruct.tokenID, hapTokenInfoRes); - EXPECT_EQ(ret, AccessTokenError::ERR_TOKENID_NOT_EXIST); -} - -/** - * @tc.name: AllocHapToken018 - * @tc.desc: alloc a tokenId with vaild dlptype. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, AllocHapToken018, TestSize.Level1) -{ - HapPolicyParams infoManagerTestPolicyPrams = { - .apl = APL_NORMAL, - .domain = "test.domain", - .permList = {}, - .permStateList = {} - }; - HapInfoParams infoManagerTestInfoParms1 = { - .userID = 1, - .bundleName = "dlp_test1", - .instIndex = 0, - .dlpType = DLP_COMMON, - .appIDDesc = "test3", - .apiVersion = DEFAULT_API_VERSION - }; - HapInfoParams infoManagerTestInfoParms2 = { - .userID = 1, - .bundleName = "dlp_test2", - .instIndex = 1, - .dlpType = DLP_READ, - .appIDDesc = "test3", - .apiVersion = DEFAULT_API_VERSION - }; - HapInfoParams infoManagerTestInfoParms3 = { - .userID = 1, - .bundleName = "dlp_test3", - .instIndex = 2, - .dlpType = DLP_FULL_CONTROL, - .appIDDesc = "test3", - .apiVersion = DEFAULT_API_VERSION - }; - GetDlpFlagTest(infoManagerTestInfoParms1, infoManagerTestPolicyPrams, DLP_COMMON); - GetDlpFlagTest(infoManagerTestInfoParms2, infoManagerTestPolicyPrams, DLP_READ); - GetDlpFlagTest(infoManagerTestInfoParms3, infoManagerTestPolicyPrams, DLP_FULL_CONTROL); -} - -/** - * @tc.name: AllocHapToken019 - * @tc.desc: cannot alloc a tokenId with invalid dlpType. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, AllocHapToken019, TestSize.Level1) -{ - AccessTokenIDEx tokenIdEx = {0}; - HapPolicyParams infoManagerTestPolicyPrams = { - .apl = APL_NORMAL, - .domain = "test.domain", - .permList = {}, - .permStateList = {} - }; - HapInfoParams infoManagerTestInfoParms1 = { - .userID = 1, - .bundleName = "accesstoken_test", - .instIndex = 4, - .dlpType = INVALID_DLP_TYPE, - .appIDDesc = "test3", - .apiVersion = DEFAULT_API_VERSION - }; - - tokenIdEx = AccessTokenKit::AllocHapToken(infoManagerTestInfoParms1, infoManagerTestPolicyPrams); - ASSERT_EQ(INVALID_TOKENID, tokenIdEx.tokenIdExStruct.tokenID); -} - -/** - * @tc.name: AvailableType001 - * @tc.desc: get permission availableType - * @tc.type: FUNC - * @tc.require:issue I82QGU - */ -HWTEST_F(AccessTokenKitTest, AvailableType001, TestSize.Level1) -{ - PermissionDef permDef; - - // test NORMAL permission - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GetDefPermission("ohos.permission.CAMERA", permDef)); - ASSERT_EQ(permDef.availableType, ATokenAvailableTypeEnum::NORMAL); - - // test MDM permission - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GetDefPermission("ohos.permission.ENTERPRISE_MANAGE_WIFI", permDef)); - ASSERT_EQ(permDef.availableType, ATokenAvailableTypeEnum::MDM); -} - -/** - * @tc.name: UpdateHapToken001 - * @tc.desc: alloc a tokenId successfully, update it successfully and verify it. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, UpdateHapToken001, TestSize.Level1) -{ - ATokenAplEnum apl = g_infoManagerTestPolicyPrams.apl; - - DeleteTestToken(); - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); - GTEST_LOG_(INFO) << "tokenID :" << tokenIdEx.tokenIdExStruct.tokenID; - AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; - GTEST_LOG_(INFO) << "tokenID :" << tokenID; - g_infoManagerTestPolicyPrams.apl = APL_SYSTEM_BASIC; - UpdateHapInfoParams info; - info.appIDDesc = "housework app"; - info.apiVersion = DEFAULT_API_VERSION; - info.isSystemApp = false; - info.appDistributionType = "enterprise_mdm"; - int ret = AccessTokenKit::UpdateHapToken( - tokenIdEx, info, g_infoManagerTestPolicyPrams); - ASSERT_EQ(0, ret); - - HapTokenInfo hapTokenInfoRes; - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GetHapTokenInfo(tokenID, hapTokenInfoRes)); - - g_infoManagerTestPolicyPrams.apl = apl; - - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); -} - -/** - * @tc.name: UpdateHapToken002 - * @tc.desc: cannot update hap token info with invalid userId. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, UpdateHapToken002, TestSize.Level1) -{ - AccessTokenIDEx tokenIdEx = {}; - tokenIdEx.tokenIdExStruct.tokenID = TEST_TOKENID_INVALID; - tokenIdEx.tokenIdExStruct.tokenAttr = 0; - UpdateHapInfoParams info; - info.appIDDesc = "appIDDesc"; - info.apiVersion = DEFAULT_API_VERSION; - info.isSystemApp = false; - int ret = AccessTokenKit::UpdateHapToken( - tokenIdEx, info, g_infoManagerTestPolicyPrams); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); -} - -/** - * @tc.name: UpdateHapToken003 - * @tc.desc: cannot update hap token info with invalid appIDDesc. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, UpdateHapToken003, TestSize.Level1) -{ - const std::string appIDDesc (INVALID_APPIDDESC_LEN, 'x'); - - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); - - AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; - UpdateHapInfoParams info; - info.appIDDesc = appIDDesc; - info.apiVersion = DEFAULT_API_VERSION; - info.isSystemApp = false; - int ret = AccessTokenKit::UpdateHapToken(tokenIdEx, info, g_infoManagerTestPolicyPrams); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); - - HapTokenInfo hapTokenInfoRes; - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GetHapTokenInfo(tokenID, hapTokenInfoRes)); - - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); -} - -/** - * @tc.name: UpdateHapToken004 - * @tc.desc: cannot update a tokenId with invalid apl. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, UpdateHapToken004, TestSize.Level1) -{ - ATokenAplEnum apl = g_infoManagerTestPolicyPrams.apl; - - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); - - AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; - - g_infoManagerTestPolicyPrams.apl = (ATokenAplEnum)5; - UpdateHapInfoParams info; - info.appIDDesc = "housework app"; - info.apiVersion = DEFAULT_API_VERSION; - info.isSystemApp = false; - int ret = AccessTokenKit::UpdateHapToken(tokenIdEx, info, g_infoManagerTestPolicyPrams); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, ret); - - HapTokenInfo hapTokenInfoRes; - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GetHapTokenInfo(tokenID, hapTokenInfoRes)); - g_infoManagerTestPolicyPrams.apl = apl; - - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); -} - -/** - * @tc.name: UpdateHapToken005 - * @tc.desc: cannot update a tokenId with invalid string value. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, UpdateHapToken005, TestSize.Level1) -{ - std::string backUpPermission = g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName; - PermissionDef permDefResult; - - DeleteTestToken(); - AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIdExStruct.tokenID); - - UpdateHapInfoParams info; - info.appIDDesc = g_infoManagerTestInfoParms.appIDDesc; - info.apiVersion = DEFAULT_API_VERSION; - info.appDistributionType = "enterprise_mdm"; - info.isSystemApp = false; - - std::string backup = g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName; - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = ""; - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UpdateHapToken(tokenIdEx, info, g_infoManagerTestPolicyPrams)); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, AccessTokenKit::GetDefPermission( - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName, permDefResult)); - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = backup; - - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = "ohos.permission.testtmp11"; - backup = g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].bundleName; - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].bundleName = ""; - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UpdateHapToken(tokenIdEx, info, g_infoManagerTestPolicyPrams)); - ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, AccessTokenKit::GetDefPermission( - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName, permDefResult)); - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].bundleName = backup; - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = backUpPermission; - - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = "ohos.permission.testtmp12"; - backup = g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].label; - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].label = ""; - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UpdateHapToken(tokenIdEx, info, g_infoManagerTestPolicyPrams)); - ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, AccessTokenKit::GetDefPermission( - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName, permDefResult)); - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].label = backup; - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = backUpPermission; - - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = "ohos.permission.testtmp13"; - backup = g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].description; - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].description = ""; - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UpdateHapToken(tokenIdEx, info, g_infoManagerTestPolicyPrams)); - ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, AccessTokenKit::GetDefPermission( - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName, permDefResult)); - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].description = backup; - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = backUpPermission; - - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenIdEx.tokenIdExStruct.tokenID)); -} - -/** - * @tc.name: UpdateHapToken006 - * @tc.desc: update a batch of tokenId. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, UpdateHapToken006, TestSize.Level1) -{ - int allocFlag = 0; - int updateFlag = 0; - int deleteFlag = 0; - AccessTokenIDEx tokenIdEx = {0}; - vector obj; - bool exist; - HapInfoParams testInfo = g_infoManagerTestInfoParms; - DeleteTestToken(); - - for (int i = 0; i < CYCLE_TIMES; i++) { - tokenIdEx = AccessTokenKit::AllocHapToken(testInfo, g_infoManagerTestPolicyPrams); - AccessTokenID tokenID = GetAccessTokenID(testInfo.userID, testInfo.bundleName, testInfo.instIndex); - - exist = ExistInVector(obj, tokenID); - if (exist) { - allocFlag = 1; - break; - } - obj.push_back(tokenID); - testInfo.userID++; - } - - testInfo.instIndex = 1; - g_infoManagerTestPolicyPrams.apl = APL_SYSTEM_BASIC; - UpdateHapInfoParams info; - info.appIDDesc = g_infoManagerTestInfoParms.appIDDesc; - info.apiVersion = DEFAULT_API_VERSION; - info.appDistributionType = "enterprise_mdm"; - info.isSystemApp = false; - for (size_t i = 0; i < obj.size(); i++) { - AccessTokenIDEx idEx = {}; - idEx.tokenIdExStruct.tokenID = obj[i]; - idEx.tokenIdExStruct.tokenAttr = 0; - int ret = AccessTokenKit::UpdateHapToken(idEx, info, g_infoManagerTestPolicyPrams); - if (RET_SUCCESS != ret) { - updateFlag = 1; - break; - } - } - g_infoManagerTestPolicyPrams.apl = APL_NORMAL; - - for (size_t i = 0; i < obj.size(); i++) { - int ret = AccessTokenKit::DeleteToken(obj[i]); - if (RET_SUCCESS != ret) { - deleteFlag = 1; - } - } - ASSERT_EQ(allocFlag, 0); - ASSERT_EQ(updateFlag, 0); - ASSERT_EQ(deleteFlag, 0); -} - -/** - * @tc.name: UpdateHapToken007 - * @tc.desc: add new permissdef. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, UpdateHapToken007, TestSize.Level1) -{ - DeleteTestToken(); - - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); - AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; - GTEST_LOG_(INFO) << "tokenID :" << tokenID; - - PermissionDef permDefResult; - /* check permission define before update */ - ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, AccessTokenKit::GetDefPermission( - "ohos.permission.test3", permDefResult)); - - std::string backUp = g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName; - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = "ohos.permission.test3"; - UpdateHapInfoParams info; - info.appIDDesc = g_infoManagerTestInfoParms.appIDDesc; - info.apiVersion = DEFAULT_API_VERSION; - info.isSystemApp = false; - info.appDistributionType = "enterprise_mdm"; - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UpdateHapToken(tokenIdEx, info, g_infoManagerTestPolicyPrams)); - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName = backUp; - - GTEST_LOG_(INFO) << "permissionName :" << g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName; - - ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, AccessTokenKit::GetDefPermission( - "ohos.permission.test3", permDefResult)); - - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); -} -/** - * @tc.name: UpdateHapToken008 - * @tc.desc: modify permissdef's grantMode. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, UpdateHapToken008, TestSize.Level1) -{ - const std::string appIDDesc = g_infoManagerTestInfoParms.appIDDesc; - int backupMode = g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].grantMode; - std::string backupLable = g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].label; - DeleteTestToken(); - - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); - AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; - GTEST_LOG_(INFO) << "tokenID :" << tokenID; - - PermissionDef permDefResult; - /* check permission define before update */ - ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, AccessTokenKit::GetDefPermission( - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName, permDefResult)); - - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].grantMode = 0; - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].label = "updated label"; - UpdateHapInfoParams info; - info.appIDDesc = appIDDesc; - info.apiVersion = DEFAULT_API_VERSION; - info.isSystemApp = false; - info.appDistributionType = "enterprise_mdm"; - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::UpdateHapToken(tokenIdEx, info, g_infoManagerTestPolicyPrams)); - - /* check permission define after update */ - ASSERT_EQ(AccessTokenError::ERR_PERMISSION_NOT_EXIST, AccessTokenKit::GetDefPermission( - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].permissionName, permDefResult)); - - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].label = backupLable; - g_infoManagerTestPolicyPrams.permList[INDEX_ZERO].grantMode = backupMode; - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); -} - -/** - * @tc.name: UpdateHapToken009 - * @tc.desc: old permission define will not update its grantStatus. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, UpdateHapToken009, TestSize.Level1) -{ - static PermissionStateFull infoManagerTestStateA = { - .permissionName = "ohos.permission.CAMERA", - .isGeneral = true, - .resDeviceID = {"local2"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {PermissionFlag::PERMISSION_USER_SET} - }; - static HapPolicyParams infoManagerTestPolicyPrams1 = { - .apl = APL_NORMAL, - .domain = "test.domain2", - .permList = {}, - .permStateList = {infoManagerTestStateA} - }; - - int ret; - std::vector permDefList; - const std::string appIDDesc = g_infoManagerTestInfoParms.appIDDesc; - PermissionDef infoManagerTestPermDef = g_infoManagerTestPermDef1; - PermissionStateFull infoManagerTestState = infoManagerTestStateA; - std::string permission = infoManagerTestStateA.permissionName; - - DeleteTestToken(); - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, infoManagerTestPolicyPrams1); - AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; - GTEST_LOG_(INFO) << "tokenID :" << tokenID; - - ASSERT_EQ(AccessTokenKit::VerifyAccessToken(tokenID, permission, false), infoManagerTestState.grantStatus[0]); - - infoManagerTestState.grantStatus[0] = PermissionState::PERMISSION_DENIED; - HapPolicyParams infoManagerTestPolicyPrams = { - .apl = APL_NORMAL, - .domain = "test.domain", - .permList = {infoManagerTestPermDef}, - .permStateList = {infoManagerTestState} - }; - UpdateHapInfoParams info; - info.appIDDesc = appIDDesc; - info.apiVersion = DEFAULT_API_VERSION; - info.isSystemApp = false; - info.appDistributionType = "enterprise_mdm"; - ret = AccessTokenKit::UpdateHapToken(tokenIdEx, info, infoManagerTestPolicyPrams); - ASSERT_EQ(RET_SUCCESS, ret); - - ASSERT_NE(AccessTokenKit::VerifyAccessToken(tokenID, permission, false), PermissionState::PERMISSION_DENIED); - - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); -} - -/** - * @tc.name: UpdateHapToken010 - * @tc.desc: update api version. - * @tc.type: FUNC - * @tc.require:Issue Number - */ -HWTEST_F(AccessTokenKitTest, UpdateHapToken010, TestSize.Level1) -{ - AccessTokenIDEx tokenIdEx = {0}; - const std::string appIDDesc = g_infoManagerTestInfoParms.appIDDesc; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); - AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; - GTEST_LOG_(INFO) << "tokenID :" << tokenID; - - UpdateHapInfoParams info; - info.appIDDesc = appIDDesc; - info.isSystemApp = false; - info.appDistributionType = "enterprise_mdm"; - - info.apiVersion = DEFAULT_API_VERSION - 1; - int ret = AccessTokenKit::UpdateHapToken(tokenIdEx, info, g_infoManagerTestPolicyPrams); - - HapTokenInfo hapTokenInfoRes; - ret = AccessTokenKit::GetHapTokenInfo(tokenID, hapTokenInfoRes); - ASSERT_EQ(info.apiVersion, hapTokenInfoRes.apiVersion); - - info.apiVersion = DEFAULT_API_VERSION + 1; - ret = AccessTokenKit::UpdateHapToken(tokenIdEx, info, g_infoManagerTestPolicyPrams); - - ret = AccessTokenKit::GetHapTokenInfo(tokenID, hapTokenInfoRes); - ASSERT_EQ(info.apiVersion, hapTokenInfoRes.apiVersion); - - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); -} - -/** - * @tc.name: UpdateHapToken011 - * @tc.desc: AccessTokenKit::UpdateHapToken function test - * @tc.type: FUNC - * @tc.require: issueI61A6M - */ -HWTEST_F(AccessTokenKitTest, UpdateHapToken011, TestSize.Level1) -{ - AccessTokenIDEx tokenID = {0}; - HapPolicyParams policy; - UpdateHapInfoParams info; - info.appIDDesc = std::string("updateFailed"); - info.apiVersion = 0; - info.isSystemApp = false; - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, - AccessTokenKit::UpdateHapToken(tokenID, info, policy)); -} - -static void *ThreadTestFunc01(void *args) -{ - ATokenTypeEnum type; - AccessTokenID tokenID; - - for (int i = 0; i < CYCLE_TIMES; i++) { - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); - type = AccessTokenKit::GetTokenType(tokenID); - if (type != TOKEN_HAP) { - GTEST_LOG_(INFO) << "ThreadTestFunc01 failed" << tokenID; - } - } - return nullptr; -} - -static void *ThreadTestFunc02(void *args) -{ - int ret; - AccessTokenID tokenID; - HapTokenInfo hapTokenInfoRes; - - for (int i = 0; i < CYCLE_TIMES; i++) { - tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); - ret = AccessTokenKit::GetHapTokenInfo(tokenID, hapTokenInfoRes); - if (ret != RET_SUCCESS) { - GTEST_LOG_(INFO) << "ThreadTestFunc02 failed" << tokenID; - } - } - return nullptr; -} - -/** - * @tc.name: AllocHapToken011 - * @tc.desc: Mulitpulthread test. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, Mulitpulthread001, TestSize.Level1) -{ - int ret; - AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenID); - pthread_t tid[2]; - (void)pthread_create(&tid[0], nullptr, &ThreadTestFunc01, nullptr); - (void)pthread_create(&tid[1], nullptr, &ThreadTestFunc01, nullptr); - (void)pthread_join(tid[0], nullptr); - (void)pthread_join(tid[1], nullptr); - - (void)pthread_create(&tid[0], nullptr, &ThreadTestFunc02, nullptr); - (void)pthread_create(&tid[1], nullptr, &ThreadTestFunc02, nullptr); - (void)pthread_join(tid[0], nullptr); - (void)pthread_join(tid[1], nullptr); - - ret = AccessTokenKit::DeleteToken(tokenID); - ASSERT_EQ(RET_SUCCESS, ret); -} - -void ConcurrencyTask(unsigned int tokenID) -{ - uint32_t flag; - for (int i = 0; i < CYCLE_TIMES; i++) { - AccessTokenKit::GrantPermission(tokenID, TEST_PERMISSION_NAME_A_MICRO, PERMISSION_USER_FIXED); - AccessTokenKit::GetPermissionFlag(tokenID, TEST_PERMISSION_NAME_A_MICRO, flag); - AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_A_MICRO, false); - - AccessTokenKit::RevokePermission(tokenID, TEST_PERMISSION_NAME_A_MICRO, PERMISSION_USER_SET); - AccessTokenKit::GetPermissionFlag(tokenID, TEST_PERMISSION_NAME_A_MICRO, flag); - AccessTokenKit::VerifyAccessToken(tokenID, TEST_PERMISSION_NAME_A_MICRO, false); - } -} - -/** - * @tc.name: ConcurrencyTest001 - * @tc.desc: Concurrency testing - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, ConcurrencyTest001, TestSize.Level1) -{ - AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); - std::vector threadVec; - for (int i = 0; i < THREAD_NUM; i++) { - threadVec.emplace_back(std::thread(ConcurrencyTask, tokenID)); - } - for (auto it = threadVec.begin(); it != threadVec.end(); it++) { - it->join(); - } -} - -/** - * @tc.name: GetNativeTokenInfo001 - * @tc.desc: cannot get native token with invalid tokenID. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, GetNativeTokenInfo001, TestSize.Level1) -{ - AccessTokenID tokenID = 0; - NativeTokenInfo findInfo; - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, AccessTokenKit::GetNativeTokenInfo(tokenID, findInfo)); - - AccessTokenID tokenHap = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenHap); - - NativeTokenInfo nativeInfo; - HapTokenInfo hapInfo; - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, AccessTokenKit::GetNativeTokenInfo(tokenHap, nativeInfo)); - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GetHapTokenInfo(tokenHap, hapInfo)); - - AccessTokenID tokenNative = AccessTokenKit::GetNativeTokenId("token_sync_service"); - ASSERT_NE(INVALID_TOKENID, tokenNative); - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::GetNativeTokenInfo(tokenNative, nativeInfo)); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, AccessTokenKit::GetHapTokenInfo(tokenNative, hapInfo)); - - AccessTokenKit::DeleteToken(tokenHap); -} - -/** - * @tc.name: GetTokenTypeFlag001 - * @tc.desc: cannot get token type with tokenID. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, GetTokenTypeFlag001, TestSize.Level1) -{ - AccessTokenID tokenID = 0; - ATokenTypeEnum ret = AccessTokenKit::GetTokenTypeFlag(tokenID); - ASSERT_EQ(ret, TOKEN_INVALID); -} - -/** - * @tc.name: GetTokenTypeFlag002 - * @tc.desc: Get token type with native tokenID. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, GetTokenTypeFlag002, TestSize.Level1) -{ - NativeTokenInfoParams infoInstance = { - .dcapsNum = 0, - .permsNum = 0, - .aclsNum = 0, - .dcaps = nullptr, - .perms = nullptr, - .acls = nullptr, - .processName = "GetTokenTypeFlag002", - .aplStr = "system_core", - }; - uint64_t tokenId01 = GetAccessTokenId(&infoInstance); - - AccessTokenID tokenID = tokenId01 & 0xffffffff; - ATokenTypeEnum ret = AccessTokenKit::GetTokenTypeFlag(tokenID); - ASSERT_EQ(ret, TOKEN_NATIVE); -} - -/** - * @tc.name: SetPermDialogCap001 - * @tc.desc: Set permission dialog capability with noexist app. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, SetPermDialogCap001, TestSize.Level1) -{ - HapBaseInfo hapBaseInfo = { - .userID = 111, // 111: user id - .bundleName = "noexist bundle", - .instIndex = 0, - }; - - HapTokenInfo hapInfo; - ASSERT_EQ(ERR_TOKENID_NOT_EXIST, AccessTokenKit::SetPermDialogCap(hapBaseInfo, true)); -} - -/** - * @tc.name: SetPermDialogCap002 - * @tc.desc: Set permission dialog capability, and get set permissionState. - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, SetPermDialogCap002, TestSize.Level1) -{ - AccessTokenID tokenID = AllocTestToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); - HapBaseInfo hapBaseInfo = { - .userID = g_infoManagerTestInfoParms.userID, - .bundleName = g_infoManagerTestInfoParms.bundleName, - .instIndex = g_infoManagerTestInfoParms.instIndex, - }; - - std::vector permsList; - PermissionListState tmp = { - .permissionName = g_infoManagerTestPolicyPrams.permStateList[0].permissionName, - .state = PASS_OPER - }; - permsList.emplace_back(tmp); - - // test dialog is forbiddedn - ASSERT_EQ(0, AccessTokenKit::SetPermDialogCap(hapBaseInfo, true)); - SetSelfTokenID(tokenID); - PermissionGrantInfo info; - ASSERT_EQ(FORBIDDEN_OPER, AccessTokenKit::GetSelfPermissionsState(permsList, info)); - SetSelfTokenID(selfTokenId_); - - // test dialog is not forbiddedn - ASSERT_EQ(0, AccessTokenKit::SetPermDialogCap(hapBaseInfo, false)); - SetSelfTokenID(tokenID); - ASSERT_NE(FORBIDDEN_OPER, AccessTokenKit::GetSelfPermissionsState(permsList, info)); - SetSelfTokenID(selfTokenId_); - - ASSERT_EQ(RET_SUCCESS, AccessTokenKit::DeleteToken(tokenID)); -} - -/** - * @tc.name: UserPolicyTest - * @tc.desc: UserPolicyTest. - * @tc.type: FUNC - * @tc.require: - */ -HWTEST_F(AccessTokenKitTest, UserPolicyTest, TestSize.Level1) -{ - setuid(0); - const char **perms = new const char *[1]; - perms[INDEX_ZERO] = "ohos.permission.GET_SENSITIVE_PERMISSIONS"; - uint64_t tokenID = GetNativeTokenTest("TestCase", perms, 1); - EXPECT_EQ(0, SetSelfTokenID(tokenID)); - delete[] perms; - UserState user = {.userId = 100, .isActive = true}; // 100 is userId - const std::vector userList = { user }; - const std::vector permList = { "ohos.permission.INTERNET" }; - int32_t ret = AccessTokenKit::InitUserPolicy(userList, permList); - EXPECT_EQ(ret, 0); - ret = AccessTokenKit::UpdateUserPolicy(userList); - EXPECT_EQ(ret, 0); - ret = AccessTokenKit::ClearUserPolicy(); - EXPECT_EQ(ret, 0); -} - -/** - * @tc.name: GetHapTokenInfoExt001 - * @tc.desc: GetHapTokenInfoExt001. - * @tc.type: FUNC - * @tc.require: IAZTZD - */ -HWTEST_F(AccessTokenKitTest, GetHapTokenInfoExt001, TestSize.Level1) -{ - setuid(0); - AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - ASSERT_NE(INVALID_TOKENID, tokenID); - HapTokenInfoExt hapTokenInfoExt; - int ret = AccessTokenKit::GetHapTokenInfoExtension(tokenID, hapTokenInfoExt); - ASSERT_EQ(ret, 0); - ASSERT_EQ(TEST_BUNDLE_NAME, hapTokenInfoExt.baseInfo.bundleName); - ASSERT_EQ("appIDDesc", hapTokenInfoExt.appID); - - ret = AccessTokenKit::GetHapTokenInfoExtension(INVALID_TOKENID, hapTokenInfoExt); - ASSERT_EQ(ret, AccessTokenError::ERR_PARAM_INVALID); -} - -/** - * @tc.name: RequestAppPermOnSettingTest001 - * @tc.desc: RequestAppPermOnSetting invalid token. - * @tc.type: FUNC - * @tc.require: Issue - */ -HWTEST_F(AccessTokenKitTest, RequestAppPermOnSettingTest001, TestSize.Level1) -{ - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestSystemInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); - - // invalid tokenID in client - AccessTokenID tokenID = 0; - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, AccessTokenKit::RequestAppPermOnSetting(tokenID)); - // invalid tokenID in service - tokenID = 123; - ASSERT_EQ(AccessTokenError::ERR_TOKENID_NOT_EXIST, AccessTokenKit::RequestAppPermOnSetting(tokenID)); -} - -/** - * @tc.name: RequestAppPermOnSettingTest002 - * @tc.desc: RequestAppPermOnSetting not system app. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, RequestAppPermOnSettingTest002, TestSize.Level0) -{ - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestNormalInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); - - AccessTokenID tokenID = 123; - int32_t ret = AccessTokenKit::RequestAppPermOnSetting(tokenID); - ASSERT_EQ(ERR_NOT_SYSTEM_APP, ret); -} - -/** - * @tc.name: RequestAppPermOnSettingTest003 - * @tc.desc: RequestAppPermOnSetting add hap and call function. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, RequestAppPermOnSettingTest003, TestSize.Level0) -{ - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestSystemInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); - - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestNormalInfoParms, g_infoManagerTestPolicyPrams); - AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; - ASSERT_NE(INVALID_TOKENID, tokenID); - AccessTokenKit::RequestAppPermOnSetting(tokenID); -} - -/** - * @tc.name: RequestAppPermOnSettingTest004 - * @tc.desc: RequestAppPermOnSetting call function with self token. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(AccessTokenKitTest, RequestAppPermOnSettingTest004, TestSize.Level0) -{ - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestSystemInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIDEx); - EXPECT_EQ(0, SetSelfTokenID(tokenIdEx.tokenIDEx)); - - AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID; - AccessTokenKit::RequestAppPermOnSetting(tokenID); -} -} // namespace AccessToken -} // namespace Security -} // namespace OHOS diff --git a/interfaces/innerkits/accesstoken/test/unittest/src/accesstoken_kit_test.h b/interfaces/innerkits/accesstoken/test/unittest/src/accesstoken_kit_test.h deleted file mode 100644 index 892e41259aefb8636df6bf28394ef7f6ca8db296..0000000000000000000000000000000000000000 --- a/interfaces/innerkits/accesstoken/test/unittest/src/accesstoken_kit_test.h +++ /dev/null @@ -1,65 +0,0 @@ -/* - * Copyright (c) 2021-2022 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 ACCESSTOKEN_KIT_TEST_H -#define ACCESSTOKEN_KIT_TEST_H - -#include - -#include "access_token.h" -#include "accesstoken_kit.h" -#include "permission_def.h" -#include "permission_state_full.h" - -namespace OHOS { -namespace Security { -namespace AccessToken { -static const std::string TEST_BUNDLE_NAME = "ohos"; -static const std::string TEST_PERMISSION_NAME_ALPHA = "ohos.permission.ALPHA"; -static const std::string TEST_PERMISSION_NAME_BETA = "ohos.permission.BETA"; -static const std::string TEST_PERMISSION_NAME_GAMMA = "ohos.permission.GAMMA"; -static const std::string TEST_PKG_NAME = "com.softbus.test"; -static const int TEST_USER_ID = 0; -static const int TEST_USER_ID_INVALID = -1; -static const unsigned int TEST_TOKENID_INVALID = 0; -static const int INVALID_BUNDLENAME_LEN = 260; -static const int INVALID_APPIDDESC_LEN = 10244; -static const int INVALID_LABEL_LEN = 260; -static const int INVALID_DESCRIPTION_LEN = 260; -static const int INVALID_PERMNAME_LEN = 260; -static const int CYCLE_TIMES = 100; -static const int THREAD_NUM = 3; -static const int INVALID_DCAP_LEN = 1025; -static const int INVALID_DLP_TYPE = 4; -class AccessTokenKitTest : public testing::Test { -public: - static void SetUpTestCase(); - - static void TearDownTestCase(); - - void SetUp(); - - void TearDown(); - unsigned int GetAccessTokenID(int userID, std::string bundleName, int instIndex); - void DeleteTestToken() const; - AccessTokenID AllocTestToken(const HapInfoParams& hapInfo, const HapPolicyParams& hapPolicy) const; - void GetDlpFlagTest(HapInfoParams info, HapPolicyParams policy, int flag); - - uint64_t selfTokenId_; -}; -} // namespace AccessToken -} // namespace Security -} // namespace OHOS -#endif // ACCESSTOKEN_KIT_TEST_H diff --git a/interfaces/innerkits/accesstoken/test/unittest/src/accesstoken_short_time_permission_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/src/accesstoken_short_time_permission_test.cpp deleted file mode 100644 index 956b4adc369037677fd1a02b8c9edb900489f0e6..0000000000000000000000000000000000000000 --- a/interfaces/innerkits/accesstoken/test/unittest/src/accesstoken_short_time_permission_test.cpp +++ /dev/null @@ -1,252 +0,0 @@ -/* - * Copyright (c) 2024 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 "accesstoken_short_time_permission_test.h" -#include "accesstoken_kit.h" -#include "access_token_error.h" -#include "nativetoken_kit.h" -#include "token_setproc.h" - -namespace OHOS { -namespace Security { -namespace AccessToken { -namespace { -static const int32_t INDEX_ZERO = 0; -static std::string SHORT_TEMP_PERMISSION = "ohos.permission.SHORT_TERM_WRITE_IMAGEVIDEO"; -static PermissionStateFull g_permiState = { - .permissionName = SHORT_TEMP_PERMISSION, - .isGeneral = true, - .resDeviceID = {"localC"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {1} -}; - -static HapPolicyParams g_policyPrams = { - .apl = APL_NORMAL, - .domain = "test.domain", - .permStateList = {g_permiState} -}; - -static HapInfoParams g_infoParms = { - .userID = 1, - .bundleName = "AccessTokenShortTimePermTest", - .instIndex = 0, - .appIDDesc = "test.bundle", - .isSystemApp = true -}; -} - -static uint64_t GetNativeTokenTest(const char *processName, const char **perms, int32_t permNum) -{ - uint64_t tokenId; - NativeTokenInfoParams infoInstance = { - .dcapsNum = 0, - .permsNum = permNum, - .aclsNum = 0, - .dcaps = nullptr, - .perms = perms, - .acls = nullptr, - .aplStr = "system_core", - .processName = processName, - }; - - tokenId = GetAccessTokenId(&infoInstance); - AccessTokenKit::ReloadNativeTokenInfo(); - return tokenId; -} - -static void NativeTokenGet() -{ - uint64_t tokenID; - const char **perms = new const char *[1]; // 1: array size - perms[INDEX_ZERO] = "ohos.permission.DISTRIBUTED_DATASYNC"; - - tokenID = GetNativeTokenTest("AccessTokenShortTimePermTest", perms, 1); // 1: array size - EXPECT_EQ(0, SetSelfTokenID(tokenID)); - delete[] perms; -} - -using namespace testing::ext; - -void AccessTokenShortTimePermTest::SetUpTestCase() -{ - NativeTokenGet(); - GTEST_LOG_(INFO) << "tokenID is " << GetSelfTokenID(); - GTEST_LOG_(INFO) << "uid is " << getuid(); -} - -void AccessTokenShortTimePermTest::TearDownTestCase() -{ -} - -void AccessTokenShortTimePermTest::SetUp() -{ - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoParms.userID, - g_infoParms.bundleName, - g_infoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - AccessTokenKit::AllocHapToken(g_infoParms, g_policyPrams); -} - -void AccessTokenShortTimePermTest::TearDown() -{ - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoParms.userID, - g_infoParms.bundleName, - g_infoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); -} - -/** - * @tc.name: GrantPermissionForSpecifiedTime001 - * @tc.desc: GrantPermissionForSpecifiedTime without invalid parameter. - * @tc.type: FUNC - * @tc.require:Issue Number - */ -HWTEST_F(AccessTokenShortTimePermTest, GrantPermissionForSpecifiedTime001, TestSize.Level1) -{ - AccessTokenID tokenId = INVALID_TOKENID; - uint32_t onceTime = 0; - - /* 0 is invalid token id */ - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, - AccessTokenKit::GrantPermissionForSpecifiedTime(tokenId, "permission", onceTime)); - - tokenId = 123; - /* 0 is invalid permissionName length */ - const std::string invalidPerm1 = ""; - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, - AccessTokenKit::GrantPermissionForSpecifiedTime(tokenId, invalidPerm1, onceTime)); - - /* 256 is invalid permissionName length */ - const std::string invalidPerm2 (257, 'x'); - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, - AccessTokenKit::GrantPermissionForSpecifiedTime(tokenId, invalidPerm2, onceTime)); - - /* 0 is invalid time */ - uint32_t invalidOnceTime1 = 0; - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, - AccessTokenKit::GrantPermissionForSpecifiedTime(tokenId, SHORT_TEMP_PERMISSION, invalidOnceTime1)); - - /* 301 is invalid time */ - uint32_t invalidOnceTime2 = 301; - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, - AccessTokenKit::GrantPermissionForSpecifiedTime(tokenId, SHORT_TEMP_PERMISSION, invalidOnceTime2)); -} - -/** - * @tc.name: GrantPermissionForSpecifiedTime003 - * @tc.desc: permission is not request. - * @tc.type: FUNC - * @tc.require:Issue Number - */ -HWTEST_F(AccessTokenShortTimePermTest, GrantPermissionForSpecifiedTime003, TestSize.Level1) -{ - HapPolicyParams policyPrams = g_policyPrams; - HapInfoParams infoParms = g_infoParms; - policyPrams.permStateList.clear(); - - AccessTokenKit::AllocHapToken(infoParms, policyPrams); - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(infoParms.userID, - infoParms.bundleName, - infoParms.instIndex); - ASSERT_NE(INVALID_TOKENID, tokenID); - uint32_t onceTime = 10; // 10: 10s - - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, - AccessTokenKit::GrantPermissionForSpecifiedTime(tokenID, SHORT_TEMP_PERMISSION, onceTime)); -} - -/** - * @tc.name: GrantPermissionForSpecifiedTime002 - * @tc.desc: test unsupport permission. - * @tc.type: FUNC - * @tc.require:Issue Number - */ -HWTEST_F(AccessTokenShortTimePermTest, GrantPermissionForSpecifiedTime002, TestSize.Level1) -{ - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoParms.userID, - g_infoParms.bundleName, - g_infoParms.instIndex); - ASSERT_NE(INVALID_TOKENID, tokenID); - uint32_t onceTime = 10; // 10: 10s - std::string permission = "ohos.permission.CAMERA"; - - ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, - AccessTokenKit::GrantPermissionForSpecifiedTime(tokenID, permission, onceTime)); -} - -/** - * @tc.name: GrantPermissionForSpecifiedTime004 - * @tc.desc: 1. The permission is granted when onceTime is not reached; - * 2. The permission is revoked after onceTime is reached. - * @tc.type: FUNC - * @tc.require:Issue Number - */ -HWTEST_F(AccessTokenShortTimePermTest, GrantPermissionForSpecifiedTime004, TestSize.Level1) -{ - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoParms.userID, - g_infoParms.bundleName, - g_infoParms.instIndex); - ASSERT_NE(INVALID_TOKENID, tokenID); - uint32_t onceTime = 2; - - ASSERT_EQ(RET_SUCCESS, - AccessTokenKit::GrantPermissionForSpecifiedTime(tokenID, SHORT_TEMP_PERMISSION, onceTime)); - - ASSERT_EQ(PermissionState::PERMISSION_GRANTED, AccessTokenKit::VerifyAccessToken(tokenID, SHORT_TEMP_PERMISSION)); - - sleep(onceTime); - - ASSERT_EQ(PermissionState::PERMISSION_DENIED, - AccessTokenKit::VerifyAccessToken(tokenID, SHORT_TEMP_PERMISSION, true)); -} - -/** - * @tc.name: GrantPermissionForSpecifiedTime005 - * @tc.desc: 1. The permission is granted when onceTime is not reached; - * 2. onceTime is update when GrantPermissionForSpecifiedTime is called twice. - * @tc.type: FUNC - * @tc.require:Issue Number - */ -HWTEST_F(AccessTokenShortTimePermTest, GrantPermissionForSpecifiedTime005, TestSize.Level1) -{ - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoParms.userID, - g_infoParms.bundleName, - g_infoParms.instIndex); - ASSERT_NE(INVALID_TOKENID, tokenID); - uint32_t onceTime = 3; - - ASSERT_EQ(RET_SUCCESS, - AccessTokenKit::GrantPermissionForSpecifiedTime(tokenID, SHORT_TEMP_PERMISSION, onceTime)); - sleep(onceTime - 1); - ASSERT_EQ(PermissionState::PERMISSION_GRANTED, AccessTokenKit::VerifyAccessToken(tokenID, SHORT_TEMP_PERMISSION)); - - // update onceTime - onceTime = 5; - ASSERT_EQ(RET_SUCCESS, - AccessTokenKit::GrantPermissionForSpecifiedTime(tokenID, SHORT_TEMP_PERMISSION, onceTime)); - - // first onceTime is reached, permission is not revoked - sleep(1); - ASSERT_EQ(PermissionState::PERMISSION_GRANTED, AccessTokenKit::VerifyAccessToken(tokenID, SHORT_TEMP_PERMISSION)); - - // second onceTime is reached, permission is revoked - sleep(onceTime); - ASSERT_EQ(PermissionState::PERMISSION_DENIED, AccessTokenKit::VerifyAccessToken(tokenID, SHORT_TEMP_PERMISSION)); -} -} // namespace AccessToken -} // namespace Security -} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/accesstoken/test/unittest/src/accesstoken_short_time_permission_test.h b/interfaces/innerkits/accesstoken/test/unittest/src/accesstoken_short_time_permission_test.h deleted file mode 100644 index 5823417965c928145b7e8c2606dad5b0582c3e58..0000000000000000000000000000000000000000 --- a/interfaces/innerkits/accesstoken/test/unittest/src/accesstoken_short_time_permission_test.h +++ /dev/null @@ -1,34 +0,0 @@ -/* - * Copyright (c) 2024 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 ACCESSTOKEN_KIT_SHORT_TIME_PERM_TEST_H -#define ACCESSTOKEN_KIT_SHORT_TIME_PERM_TEST_H - -#include - -namespace OHOS { -namespace Security { -namespace AccessToken { -class AccessTokenShortTimePermTest : public testing::Test { -public: - static void SetUpTestCase(); - static void TearDownTestCase(); - void SetUp(); - void TearDown(); -}; -} // namespace AccessToken -} // namespace Security -} // namespace OHOS -#endif // ACCESSTOKEN_KIT_SHORT_TIME_PERM_TEST_H \ No newline at end of file diff --git a/interfaces/innerkits/accesstoken/test/unittest/src/remote_token_kit_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/src/remote_token_kit_test.cpp deleted file mode 100644 index 6a31c51861399cb7ad6d4b8f6e2e541817ce06b8..0000000000000000000000000000000000000000 --- a/interfaces/innerkits/accesstoken/test/unittest/src/remote_token_kit_test.cpp +++ /dev/null @@ -1,227 +0,0 @@ -/* - * Copyright (c) 2022-2024 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 "remote_token_kit_test.h" -#include - -#include "accesstoken_kit.h" -#include "accesstoken_common_log.h" -#include "access_token_error.h" -#include "nativetoken_kit.h" -#include "token_setproc.h" - -using namespace testing::ext; -using namespace OHOS::Security::AccessToken; - -namespace { -static const std::string TEST_BUNDLE_NAME = "ohos"; -static const std::string TEST_PKG_NAME = "com.softbus.test"; -static const int TEST_USER_ID = 0; - -PermissionDef g_infoManagerTestPermDef1 = { - .permissionName = "ohos.permission.test1", - .bundleName = "accesstoken_test", - .grantMode = 1, - .availableLevel = APL_NORMAL, - .label = "label4", - .labelId = 1, - .description = "open the door", - .descriptionId = 1, -}; - -PermissionDef g_infoManagerTestPermDef2 = { - .permissionName = "ohos.permission.test2", - .bundleName = "accesstoken_test", - .grantMode = 1, - .availableLevel = APL_NORMAL, - .label = "label4", - .labelId = 1, - .description = "break the door", - .descriptionId = 1, -}; - -PermissionStateFull g_infoManagerTestState1 = { - .permissionName = "ohos.permission.GET_WIFI_INFO", - .isGeneral = true, - .resDeviceID = {"local4"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED}, - .grantFlags = {1}, -}; - -PermissionStateFull g_infoManagerTestState2 = { - .permissionName = "ohos.permission.SET_WIFI_INFO", - .isGeneral = false, - .resDeviceID = {"device 1", "device 2"}, - .grantStatus = {PermissionState::PERMISSION_GRANTED, PermissionState::PERMISSION_GRANTED}, - .grantFlags = {1, 2}, -}; - -HapInfoParams g_infoManagerTestInfoParms = { - .userID = 1, - .bundleName = "accesstoken_test", - .instIndex = 0, - .appIDDesc = "test4" -}; - -HapPolicyParams g_infoManagerTestPolicyPrams = { - .apl = APL_NORMAL, - .domain = "test.domain4", - .permList = {g_infoManagerTestPermDef1, g_infoManagerTestPermDef2}, - .permStateList = {g_infoManagerTestState1, g_infoManagerTestState2} -}; - -HapInfoParams g_infoManagerTestInfoParmsBak = { - .userID = 1, - .bundleName = "accesstoken_test", - .instIndex = 0, - .appIDDesc = "test4" -}; - -HapPolicyParams g_infoManagerTestPolicyPramsBak = { - .apl = APL_NORMAL, - .domain = "test.domain4", - .permList = {g_infoManagerTestPermDef1, g_infoManagerTestPermDef2}, - .permStateList = {g_infoManagerTestState1, g_infoManagerTestState2} -}; - -HapTokenInfo g_baseInfo = { - .ver = 1, - .userID = 1, - .bundleName = "com.ohos.access_token", - .instIndex = 1, - .tokenID = 0x20100000, - .tokenAttr = 0 -}; - -void NativeTokenGet() -{ - uint32_t tokenId = AccessTokenKit::GetNativeTokenId("token_sync_service"); - ASSERT_NE(tokenId, INVALID_TOKENID); - EXPECT_EQ(0, SetSelfTokenID(tokenId)); -} - -#ifdef TOKEN_SYNC_ENABLE -static const int32_t FAKE_SYNC_RET = 0xabcdef; -class TokenSyncCallbackImpl : public TokenSyncKitInterface { -public: - ~TokenSyncCallbackImpl() - {} - - int32_t GetRemoteHapTokenInfo(const std::string& deviceID, AccessTokenID tokenID) const override - { - LOGI(ATM_DOMAIN, ATM_TAG, "GetRemoteHapTokenInfo called."); - return FAKE_SYNC_RET; - }; - - int32_t DeleteRemoteHapTokenInfo(AccessTokenID tokenID) const override - { - LOGI(ATM_DOMAIN, ATM_TAG, "DeleteRemoteHapTokenInfo called."); - return FAKE_SYNC_RET; - }; - - int32_t UpdateRemoteHapTokenInfo(const HapTokenInfoForSync& tokenInfo) const override - { - LOGI(ATM_DOMAIN, ATM_TAG, "UpdateRemoteHapTokenInfo called."); - return FAKE_SYNC_RET; - }; -}; -#endif -} - -void RemoteTokenKitTest::SetUpTestCase() -{ - // make test case clean - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - - tokenID = AccessTokenKit::GetHapTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenID); - - NativeTokenGet(); - -#ifdef TOKEN_SYNC_ENABLE - std::shared_ptr ptrDmInitCallback = std::make_shared(); - int32_t res = DistributedHardware::DeviceManager::GetInstance().InitDeviceManager(TEST_PKG_NAME, ptrDmInitCallback); - ASSERT_EQ(res, RET_SUCCESS); -#endif -} - -void RemoteTokenKitTest::TearDownTestCase() -{ -#ifdef TOKEN_SYNC_ENABLE - int32_t res = DistributedHardware::DeviceManager::GetInstance().UnInitDeviceManager(TEST_PKG_NAME); - ASSERT_EQ(res, RET_SUCCESS); -#endif -} - -void RemoteTokenKitTest::SetUp() -{ - selfTokenId_ = GetSelfTokenID(); - g_infoManagerTestInfoParms = g_infoManagerTestInfoParmsBak; - g_infoManagerTestPolicyPrams = g_infoManagerTestPolicyPramsBak; - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); - AccessTokenKit::DeleteToken(tokenID); - -#ifdef TOKEN_SYNC_ENABLE - DistributedHardware::DmDeviceInfo deviceInfo; - int32_t res = DistributedHardware::DeviceManager::GetInstance().GetLocalDeviceInfo(TEST_PKG_NAME, deviceInfo); - ASSERT_EQ(res, RET_SUCCESS); - - networkId_ = std::string(deviceInfo.networkId); - ASSERT_NE(networkId_, ""); - - res = DistributedHardware::DeviceManager::GetInstance().GetUdidByNetworkId(TEST_PKG_NAME, networkId_, udid_); - ASSERT_EQ(res, RET_SUCCESS); - ASSERT_NE(udid_, ""); -#endif - - LOGI(ATM_DOMAIN, ATM_TAG, "SetUp ok."); -} - -void RemoteTokenKitTest::TearDown() -{ - AccessTokenID tokenID = GetAccessTokenID(TEST_USER_ID, TEST_BUNDLE_NAME, 0); - AccessTokenKit::DeleteToken(tokenID); - EXPECT_EQ(0, SetSelfTokenID(selfTokenId_)); - udid_.clear(); - networkId_.clear(); -} - -unsigned int RemoteTokenKitTest::GetAccessTokenID(int userID, std::string bundleName, int instIndex) -{ - return AccessTokenKit::GetHapTokenID(userID, bundleName, instIndex); -} - -void RemoteTokenKitTest::DeleteTestToken() const -{ - AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_infoManagerTestInfoParms.userID, - g_infoManagerTestInfoParms.bundleName, - g_infoManagerTestInfoParms.instIndex); - int ret = AccessTokenKit::DeleteToken(tokenID); - if (tokenID != 0) { - ASSERT_EQ(RET_SUCCESS, ret); - } -} - -void RemoteTokenKitTest::AllocTestToken() const -{ - AccessTokenIDEx tokenIdEx = {0}; - tokenIdEx = AccessTokenKit::AllocHapToken(g_infoManagerTestInfoParms, g_infoManagerTestPolicyPrams); - ASSERT_NE(INVALID_TOKENID, tokenIdEx.tokenIdExStruct.tokenID); -} diff --git a/interfaces/innerkits/accesstoken/test/unittest/src/remote_token_kit_test.h b/interfaces/innerkits/accesstoken/test/unittest/src/remote_token_kit_test.h deleted file mode 100644 index 830e56ef54c2175a39895e7b89aa30c55b4a1da4..0000000000000000000000000000000000000000 --- a/interfaces/innerkits/accesstoken/test/unittest/src/remote_token_kit_test.h +++ /dev/null @@ -1,56 +0,0 @@ -/* - * Copyright (c) 2022 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 REMOTE_TOKEN_KIT_TEST_H -#define REMOTE_TOKEN_KIT_TEST_H - -#include -#include "access_token.h" -#ifdef TOKEN_SYNC_ENABLE -#include "device_manager.h" -#endif -#include "permission_def.h" -#include "permission_state_full.h" - -namespace OHOS { -namespace Security { -namespace AccessToken { -#ifdef TOKEN_SYNC_ENABLE -class TestDmInitCallback final : public OHOS::DistributedHardware::DmInitCallback { - void OnRemoteDied() override - {} -}; -#endif - -class RemoteTokenKitTest : public testing::Test { -public: - static void SetUpTestCase(); - - static void TearDownTestCase(); - - void SetUp(); - - void TearDown(); - unsigned int GetAccessTokenID(int userID, std::string bundleName, int instIndex); - void DeleteTestToken() const; - void AllocTestToken() const; - uint64_t selfTokenId_; - std::string udid_; - std::string networkId_; -}; -} // namespace AccessToken -} // namespace Security -} // namespace OHOS -#endif // REMOTE_TOKEN_KIT_TEST_H \ No newline at end of file