1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "delete_remote_token_test.h"
17 #include <thread>
18
19 #include "accesstoken_kit.h"
20 #include "accesstoken_common_log.h"
21 #include "access_token_error.h"
22 #include "nativetoken_kit.h"
23 #include "test_common.h"
24 #include "token_setproc.h"
25
26 using namespace testing::ext;
27 using namespace OHOS::Security::AccessToken;
28
29 namespace {
30 static const std::string TEST_BUNDLE_NAME = "ohos";
31 static const std::string TEST_PKG_NAME = "com.softbus.test";
32 static uint64_t g_selfTokenId = 0;
33 HapInfoParams g_infoManagerTestInfoParms = TestCommon::GetInfoManagerTestInfoParms();
34 static AccessTokenID g_testTokenId = 0x20100000;
35
36 HapTokenInfo g_baseInfo = {
37 .ver = 1,
38 .userID = 1,
39 .bundleName = "com.ohos.access_token",
40 .instIndex = 1,
41 .tokenID = g_testTokenId,
42 .tokenAttr = 0
43 };
44
45 #ifdef TOKEN_SYNC_ENABLE
46 static const int32_t FAKE_SYNC_RET = 0xabcdef;
47 class TokenSyncCallbackImpl : public TokenSyncKitInterface {
48 public:
~TokenSyncCallbackImpl()49 ~TokenSyncCallbackImpl()
50 {}
51
GetRemoteHapTokenInfo(const std::string & deviceID,AccessTokenID tokenID) const52 int32_t GetRemoteHapTokenInfo(const std::string& deviceID, AccessTokenID tokenID) const override
53 {
54 LOGI(ATM_DOMAIN, ATM_TAG, "GetRemoteHapTokenInfo called.");
55 return FAKE_SYNC_RET;
56 };
57
DeleteRemoteHapTokenInfo(AccessTokenID tokenID) const58 int32_t DeleteRemoteHapTokenInfo(AccessTokenID tokenID) const override
59 {
60 LOGI(ATM_DOMAIN, ATM_TAG, "DeleteRemoteHapTokenInfo called.");
61 return FAKE_SYNC_RET;
62 };
63
UpdateRemoteHapTokenInfo(const HapTokenInfoForSync & tokenInfo) const64 int32_t UpdateRemoteHapTokenInfo(const HapTokenInfoForSync& tokenInfo) const override
65 {
66 LOGI(ATM_DOMAIN, ATM_TAG, "UpdateRemoteHapTokenInfo called.");
67 return FAKE_SYNC_RET;
68 };
69 };
70 #endif
71 }
72
SetUpTestCase()73 void DeleteRemoteTokenTest::SetUpTestCase()
74 {
75 g_selfTokenId = GetSelfTokenID();
76 TestCommon::SetTestEvironment(g_selfTokenId);
77
78 // make test case clean
79 AccessTokenIDEx tokenIdEx = TestCommon::GetHapTokenIdFromBundle(g_infoManagerTestInfoParms.userID,
80 g_infoManagerTestInfoParms.bundleName, g_infoManagerTestInfoParms.instIndex);
81 TestCommon::DeleteTestHapToken(tokenIdEx.tokenIdExStruct.tokenID);
82
83 #ifdef TOKEN_SYNC_ENABLE
84 {
85 MockNativeToken mock("foundation");
86 std::shared_ptr<TestDmInitCallback> ptrDmInitCallback = std::make_shared<TestDmInitCallback>();
87 int32_t res =
88 DistributedHardware::DeviceManager::GetInstance().InitDeviceManager(TEST_PKG_NAME, ptrDmInitCallback);
89 ASSERT_EQ(res, RET_SUCCESS);
90 }
91 #endif
92 }
93
TearDownTestCase()94 void DeleteRemoteTokenTest::TearDownTestCase()
95 {
96 #ifdef TOKEN_SYNC_ENABLE
97 {
98 MockNativeToken mock("foundation");
99 int32_t res = DistributedHardware::DeviceManager::GetInstance().UnInitDeviceManager(TEST_PKG_NAME);
100 ASSERT_EQ(res, RET_SUCCESS);
101 }
102 #endif
103 EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId));
104 TestCommon::ResetTestEvironment();
105 }
106
SetUp()107 void DeleteRemoteTokenTest::SetUp()
108 {
109 #ifdef TOKEN_SYNC_ENABLE
110 MockNativeToken mock("foundation");
111 DistributedHardware::DmDeviceInfo deviceInfo;
112 int32_t res = DistributedHardware::DeviceManager::GetInstance().GetLocalDeviceInfo(TEST_PKG_NAME, deviceInfo);
113 ASSERT_EQ(res, RET_SUCCESS);
114
115 networkId_ = std::string(deviceInfo.networkId);
116 ASSERT_NE(networkId_, "");
117
118 res = DistributedHardware::DeviceManager::GetInstance().GetUdidByNetworkId(TEST_PKG_NAME, networkId_, udid_);
119 ASSERT_EQ(res, RET_SUCCESS);
120 ASSERT_NE(udid_, "");
121 #endif
122
123 LOGI(ATM_DOMAIN, ATM_TAG, "SetUp ok.");
124 }
125
TearDown()126 void DeleteRemoteTokenTest::TearDown()
127 {
128 EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId));
129 udid_.clear();
130 networkId_.clear();
131 }
132
133 #ifdef TOKEN_SYNC_ENABLE
134 /**
135 * @tc.name: DeleteRemoteTokenAbnormalTest001
136 * @tc.desc: DeleteRemoteToken with invalid parameters.
137 * @tc.type: FUNC
138 * @tc.require:Issue Number
139 */
140 HWTEST_F(DeleteRemoteTokenTest, DeleteRemoteTokenAbnormalTest001, TestSize.Level0)
141 {
142 LOGI(ATM_DOMAIN, ATM_TAG, "DeleteRemoteTokenAbnormalTest001 start.");
143 MockNativeToken mock("token_sync_service");
144
145 std::string deviceId = "device";
146 AccessTokenID tokenID = INVALID_TOKENID;
147
148 // invalid device
149 int res = AccessTokenKit::DeleteRemoteToken("", tokenID);
150 ASSERT_EQ(AccessTokenError::ERR_PARAM_INVALID, res);
151
152 // invalid tokenId
153 res = AccessTokenKit::DeleteRemoteToken(deviceId, tokenID);
154 ASSERT_NE(RET_SUCCESS, res);
155 }
156
157 /**
158 * @tc.name: DeleteRemoteTokenAbnormalTest002
159 * @tc.desc: DeleteRemoteToken with no permission
160 * @tc.type: FUNC
161 * @tc.require:
162 */
163 HWTEST_F(DeleteRemoteTokenTest, DeleteRemoteTokenAbnormalTest002, TestSize.Level0)
164 {
165 LOGI(ATM_DOMAIN, ATM_TAG, "DeleteRemoteTokenAbnormalTest002 start.");
166 std::string device = "device";
167 AccessTokenID tokenId = 123;
168 ASSERT_EQ(AccessTokenError::ERR_PERMISSION_DENIED, AccessTokenKit::DeleteRemoteToken(device, tokenId));
169 }
170
171 /**
172 * @tc.name: DeleteRemoteTokenFuncTest001
173 * @tc.desc: delete exist device mapping tokenId
174 * @tc.type: FUNC
175 * @tc.require:issue I5R4UF
176 */
177 HWTEST_F(DeleteRemoteTokenTest, DeleteRemoteTokenFuncTest001, TestSize.Level0)
178 {
179 MockNativeToken mock("token_sync_service");
180 LOGI(ATM_DOMAIN, ATM_TAG, "DeleteRemoteTokenFuncTest001 start.");
181 std::string deviceID1 = udid_;
182 AccessTokenKit::DeleteRemoteToken(deviceID1, g_testTokenId);
183 PermissionStatus infoManagerTestState_3 = {
184 .permissionName = "ohos.permission.test1",
185 .grantStatus = PermissionState::PERMISSION_GRANTED,
186 .grantFlag = PermissionFlag::PERMISSION_USER_SET};
187 std::vector<PermissionStatus> permStateList1;
188 permStateList1.emplace_back(infoManagerTestState_3);
189
190 HapTokenInfoForSync remoteTokenInfo11 = {
191 .baseInfo = g_baseInfo,
192 .permStateList = permStateList1
193 };
194
195 int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID1, remoteTokenInfo11);
196 ASSERT_EQ(ret, RET_SUCCESS);
197
198 AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, g_testTokenId);
199 ASSERT_NE(mapID, 0);
200
201 HapTokenInfo info;
202 ret = AccessTokenKit::GetHapTokenInfo(mapID, info);
203 ASSERT_EQ(ret, RET_SUCCESS);
204
205 ret = AccessTokenKit::DeleteRemoteToken(deviceID1, g_testTokenId);
206 ASSERT_EQ(ret, RET_SUCCESS);
207
208 ret = AccessTokenKit::GetHapTokenInfo(mapID, info);
209 ASSERT_NE(ret, RET_SUCCESS);
210 }
211
212 /**
213 * @tc.name: DeleteRemoteTokenFuncTest002
214 * @tc.desc: delete exist device mapping tokenId
215 * @tc.type: FUNC
216 * @tc.require:issue I5R4UF
217 */
218 HWTEST_F(DeleteRemoteTokenTest, DeleteRemoteTokenFuncTest002, TestSize.Level0)
219 {
220 MockNativeToken mock("token_sync_service");
221 LOGI(ATM_DOMAIN, ATM_TAG, "DeleteRemoteTokenFuncTest002 start.");
222 std::string deviceID2 = udid_;
223 AccessTokenKit::DeleteRemoteToken(deviceID2, g_testTokenId);
224 PermissionStatus infoManagerTestState_2 = {
225 .permissionName = "ohos.permission.test1",
226 .grantStatus = PermissionState::PERMISSION_GRANTED,
227 .grantFlag = PermissionFlag::PERMISSION_USER_SET};
228 std::vector<PermissionStatus> permStateList2;
229 permStateList2.emplace_back(infoManagerTestState_2);
230
231 HapTokenInfoForSync remoteTokenInfo2 = {
232 .baseInfo = g_baseInfo,
233 .permStateList = permStateList2
234 };
235
236 int ret = AccessTokenKit::SetRemoteHapTokenInfo(deviceID2, remoteTokenInfo2);
237 ASSERT_EQ(ret, RET_SUCCESS);
238
239 AccessTokenID mapID = AccessTokenKit::AllocLocalTokenID(networkId_, g_testTokenId);
240 ASSERT_NE(mapID, 0);
241
242 HapTokenInfo info;
243 ret = AccessTokenKit::GetHapTokenInfo(mapID, info);
244 ASSERT_EQ(ret, RET_SUCCESS);
245
246 ret = AccessTokenKit::DeleteRemoteToken(deviceID2, 0);
247 ASSERT_NE(ret, RET_SUCCESS);
248
249 // deviceID is wrong
250 std::string wrongStr(10241, 'x');
251 deviceID2 = wrongStr;
252 ret = AccessTokenKit::DeleteRemoteToken(deviceID2, g_testTokenId);
253 ASSERT_NE(ret, RET_SUCCESS);
254 }
255
256 /**
257 * @tc.name: DeleteRemoteTokenFuncTest003
258 * @tc.desc: delete exist device mapping tokenId
259 * @tc.type: FUNC
260 * @tc.require:issue I5R4UF
261 */
262 HWTEST_F(DeleteRemoteTokenTest, DeleteRemoteTokenFuncTest003, TestSize.Level0)
263 {
264 MockNativeToken mock("token_sync_service");
265 LOGI(ATM_DOMAIN, ATM_TAG, "DeleteRemoteTokenFuncTest003 start.");
266 std::string deviceID3 = udid_;
267 AccessTokenKit::DeleteRemoteToken(deviceID3, g_testTokenId);
268
269 int ret = AccessTokenKit::DeleteRemoteToken(deviceID3, g_testTokenId);
270 ASSERT_NE(ret, RET_SUCCESS);
271 }
272 #endif