1 /*
2 * Copyright (C) 2023 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 #include "gtest/gtest.h"
16 #include <tuple>
17 #include <string>
18 #include "inner_verify_status.h"
19 #include "datetime_ex.h"
20 #include "mock_constant.h"
21 #define private public
22 #define protected public
23 #include "verify_task.h"
24 #undef private
25 #undef protected
26 #include "moc_verify_task.h"
27 #include "verify_http_task.h"
28 namespace OHOS::AppDomainVerify {
29 using namespace testing;
30 using namespace testing::ext;
31
32 class DomainVerifierTaskTest : public testing::Test {
33 public:
34 static void SetUpTestCase(void);
35 static void TearDownTestCase(void);
36 void SetUp();
37 void TearDown();
38 };
39
SetUpTestCase(void)40 void DomainVerifierTaskTest::SetUpTestCase(void)
41 {
42 }
43
TearDownTestCase(void)44 void DomainVerifierTaskTest::TearDownTestCase(void)
45 {
46 }
47
SetUp(void)48 void DomainVerifierTaskTest::SetUp(void)
49 {
50 }
51
TearDown(void)52 void DomainVerifierTaskTest::TearDown(void)
53 {
54 }
55 /**
56 * @tc.name: DomainVerifierTaskTest001
57 * @tc.desc:
58 * @tc.type: FUNC
59 */
60 HWTEST_F(DomainVerifierTaskTest, DomainVerifierTaskTest001, TestSize.Level0)
61 {
62 AppVerifyBaseInfo appVerifyBaseInfo;
63 appVerifyBaseInfo.bundleName = "";
64 appVerifyBaseInfo.fingerprint = "";
65 appVerifyBaseInfo.appIdentifier = "";
66 SkillUri uri1;
67 VerifyResultInfo verifyResultInfo;
68 VerifyTask task(TaskType::IMMEDIATE_TASK, appVerifyBaseInfo, verifyResultInfo);
69 task.Execute();
70 ASSERT_TRUE(task.GetType() == TaskType::IMMEDIATE_TASK);
71 ASSERT_TRUE(task.GetTaskType() == TaskType::IMMEDIATE_TASK);
72 ASSERT_TRUE(task.GetAppVerifyBaseInfo().bundleName == "");
73 ASSERT_TRUE(task.GetUriVerifyMap().empty());
74 ASSERT_FALSE(task.SaveDomainVerifyStatus("", verifyResultInfo));
75 }
76 /**
77 * @tc.name: DomainVerifierTaskTest002
78 * @tc.desc:
79 * @tc.type: FUNC
80 */
81 HWTEST_F(DomainVerifierTaskTest, DomainVerifierTaskTest002, TestSize.Level0)
82 {
83 AppVerifyBaseInfo appVerifyBaseInfo;
84 appVerifyBaseInfo.bundleName = "";
85 appVerifyBaseInfo.fingerprint = "";
86 appVerifyBaseInfo.appIdentifier = "";
87 std::vector<SkillUri> skillUris;
88 SkillUri uri1;
89 uri1.host = "test";
90 uri1.scheme = "";
91 skillUris.push_back(uri1);
92
93 SkillUri uri2;
94 uri2.host = "";
95 uri2.scheme = "";
96 skillUris.push_back(uri2);
97
98 SkillUri uri3;
99 uri3.host = "";
100 uri3.scheme = "https";
101 skillUris.push_back(uri3);
102
103 SkillUri uri4;
104 uri4.host = "test";
105 uri4.scheme = "https";
106 skillUris.push_back(uri4);
107
108 SkillUri uri5;
109 uri4.host = "test/a";
110 uri4.scheme = "https";
111 skillUris.push_back(uri5);
112
113 SkillUri uri6;
114 uri6.host = "";
115 uri6.scheme = "https";
116 skillUris.push_back(uri6);
117
118 SkillUri uri7;
119 uri7.host = "test";
120 uri7.scheme = "https";
121 skillUris.push_back(uri7);
122
123 SkillUri uri8;
124 uri8.host = "test/a";
125 uri8.scheme = "https";
126 skillUris.push_back(uri8);
127
128 VerifyResultInfo verifyResultInfo;
129 VerifyTask task(TaskType::IMMEDIATE_TASK, appVerifyBaseInfo, verifyResultInfo);
130 ASSERT_TRUE(task.GetType() == TaskType::IMMEDIATE_TASK);
131 }
132 /**
133 * @tc.name: DomainVerifierTaskTest003
134 * @tc.desc:
135 * @tc.type: FUNC
136 */
137 HWTEST_F(DomainVerifierTaskTest, DomainVerifierTaskTest003, TestSize.Level0)
138 {
139 AppVerifyBaseInfo appVerifyBaseInfo;
140 appVerifyBaseInfo.bundleName = "";
141 appVerifyBaseInfo.fingerprint = "";
142 appVerifyBaseInfo.appIdentifier = "";
143 SkillUri uri1;
144 uri1.scheme = "https";
145 uri1.host = "e";
146 VerifyResultInfo verifyResultInfo;
147 VerifyTask task(TaskType::IMMEDIATE_TASK, appVerifyBaseInfo, verifyResultInfo);
148 OHOS::NetStack::HttpClient::HttpClientRequest request;
149 std::string url = "";
150 ASSERT_TRUE(task.OnPreRequest(request, url));
151 }
152 /**
153 * @tc.name: DomainVerifierTaskTest004
154 * @tc.desc:
155 * @tc.type: FUNC
156 */
157 HWTEST_F(DomainVerifierTaskTest, DomainVerifierTaskTest004, TestSize.Level0)
158 {
159 AppVerifyBaseInfo appVerifyBaseInfo;
160 appVerifyBaseInfo.bundleName = "";
161 appVerifyBaseInfo.fingerprint = "";
162 appVerifyBaseInfo.appIdentifier = "";
163 SkillUri uri1;
164 uri1.scheme = "https";
165 uri1.host = "e";
166 VerifyResultInfo verifyResultInfo;
167 VerifyTask task(TaskType::IMMEDIATE_TASK, appVerifyBaseInfo, verifyResultInfo);
168 OHOS::NetStack::HttpClient::HttpClientResponse response;
169 response.SetResponseCode(OHOS::NetStack::HttpClient::ResponseCode::OK);
170 response.SetResult("OK");
171 std::string url = "";
172 task.OnPostVerify(url, response);
173 ASSERT_TRUE(task.unVerifiedSet_.empty());
174 }
175
176 /**
177 * @tc.name: DomainVerifierTaskTest005
178 * @tc.desc:
179 * @tc.type: FUNC
180 */
181 HWTEST_F(DomainVerifierTaskTest, DomainVerifierTaskTest005, TestSize.Level0)
182 {
183 AppVerifyBaseInfo appVerifyBaseInfo;
184 appVerifyBaseInfo.bundleName = "";
185 appVerifyBaseInfo.fingerprint = "";
186 appVerifyBaseInfo.appIdentifier = "";
187 SkillUri uri1;
188 uri1.scheme = "https";
189 uri1.host = "e";
190 VerifyResultInfo verifyResultInfo;
191 VerifyTask task(TaskType::IMMEDIATE_TASK, appVerifyBaseInfo, verifyResultInfo);
192 OHOS::NetStack::HttpClient::HttpClientResponse response;
193 response.SetResponseCode(OHOS::NetStack::HttpClient::ResponseCode::OK);
194 response.SetResult("OK");
195 std::string url = "test1";
196 task.UpdateVerifyResultInfo(url, FAILURE_CLIENT_ERROR);
197 auto hostVerifyStatusMap = task.GetUriVerifyMap();
198 ASSERT_TRUE(hostVerifyStatusMap.find(url) != hostVerifyStatusMap.end());
199 InnerVerifyStatus status;
200 std::string verifyTime;
201 int verifyCnt = 0;
202 std::tie(status, verifyTime, verifyCnt) = hostVerifyStatusMap.at(url);
203 ASSERT_EQ(status, FAILURE_CLIENT_ERROR);
204 ASSERT_EQ(verifyCnt, 0);
205 task.UpdateVerifyResultInfo(url, FAILURE_CLIENT_ERROR);
206 hostVerifyStatusMap = task.GetUriVerifyMap();
207 std::tie(status, verifyTime, verifyCnt) = hostVerifyStatusMap.at(url);
208 ASSERT_EQ(status, FAILURE_CLIENT_ERROR);
209 ASSERT_EQ(verifyCnt, 1);
210 task.UpdateVerifyResultInfo(url, FAILURE_HTTP_UNKNOWN);
211 hostVerifyStatusMap = task.GetUriVerifyMap();
212 std::tie(status, verifyTime, verifyCnt) = hostVerifyStatusMap.at(url);
213 ASSERT_EQ(status, FAILURE_HTTP_UNKNOWN);
214 ASSERT_EQ(verifyCnt, 0);
215 }
216
217 /**
218 * @tc.name: DomainVerifierTaskTest006
219 * @tc.desc:
220 * @tc.type: FUNC
221 */
222 HWTEST_F(DomainVerifierTaskTest, DomainVerifierTaskTest006, TestSize.Level0)
223 {
224 AppVerifyBaseInfo appVerifyBaseInfo;
225 appVerifyBaseInfo.bundleName = "";
226 appVerifyBaseInfo.fingerprint = "";
227 appVerifyBaseInfo.appIdentifier = "";
228 SkillUri uri1;
229 uri1.scheme = "https";
230 uri1.host = "e";
231 VerifyResultInfo verifyResultInfo;
232 VerifyTask task(TaskType::IMMEDIATE_TASK, appVerifyBaseInfo, verifyResultInfo);
233 std::tuple<InnerVerifyStatus, std::string, int> info;
234 std::get<0>(info) = FAILURE_CLIENT_ERROR;
235 std::get<1>(info) = std::to_string(GetSecondsSince1970ToNow());
236 std::get<2>(info) = 1;
237 ASSERT_FALSE(task.IsNeedRetry(info));
238 std::get<1>(info) = std::to_string(GetSecondsSince1970ToNow() - 3600 * 5);
239 ASSERT_TRUE(task.IsNeedRetry(info));
240 std::get<1>(info) = std::to_string(GetSecondsSince1970ToNow() - 3600 * 1);
241 ASSERT_FALSE(task.IsNeedRetry(info));
242 std::get<1>(info) = std::to_string(GetSecondsSince1970ToNow() - 3600 * 3);
243 std::get<2>(info) = 2;
244 ASSERT_FALSE(task.IsNeedRetry(info));
245 std::get<0>(info) = FAILURE_HTTP_UNKNOWN;
246 ASSERT_TRUE(task.IsNeedRetry(info));
247 std::get<0>(info) = STATE_SUCCESS;
248 ASSERT_FALSE(task.IsNeedRetry(info));
249 std::get<0>(info) = FORBIDDEN_FOREVER;
250 ASSERT_FALSE(task.IsNeedRetry(info));
251 }
252
253 /**
254 * @tc.name: DomainVerifierTaskTest007
255 * @tc.desc:
256 * @tc.type: FUNC
257 */
258 HWTEST_F(DomainVerifierTaskTest, DomainVerifierTaskTest007, TestSize.Level0)
259 {
260 AppVerifyBaseInfo appVerifyBaseInfo;
261 appVerifyBaseInfo.bundleName = "";
262 appVerifyBaseInfo.fingerprint = "";
263 appVerifyBaseInfo.appIdentifier = "";
264 SkillUri uri1;
265 uri1.scheme = "https";
266 uri1.host = "e";
267 VerifyResultInfo verifyResultInfo;
268 VerifyTask task(TaskType::IMMEDIATE_TASK, appVerifyBaseInfo, verifyResultInfo);
269 int64_t time = task.CalcRetryDuration(0);
270 ASSERT_EQ(time, 3600);
271 time = task.CalcRetryDuration(7);
272 ASSERT_EQ(time, 460800);
273 }
274
275 /**
276 * @tc.name: DomainVerifierTaskSaveResultTest001
277 * @tc.desc:
278 * @tc.type: FUNC
279 */
280 HWTEST_F(DomainVerifierTaskTest, DomainVerifierTaskSaveResultTest001, TestSize.Level0)
281 {
282 AppVerifyBaseInfo appVerifyBaseInfo;
283 appVerifyBaseInfo.bundleName = "";
284 appVerifyBaseInfo.fingerprint = "";
285 appVerifyBaseInfo.appIdentifier = "";
286 SkillUri uri1;
287 uri1.scheme = "https";
288 uri1.host = "e";
289 VerifyResultInfo verifyResultInfo;
290 MocVerifyTask task(TaskType::IMMEDIATE_TASK, appVerifyBaseInfo, verifyResultInfo);
291 OHOS::NetStack::HttpClient::HttpClientResponse response;
292 response.SetResponseCode(OHOS::NetStack::HttpClient::ResponseCode::OK);
293 response.SetResult("OK");
294 std::string url = "";
295
296 EXPECT_CALL(task, SaveDomainVerifyStatus(_, _)).Times(1).WillOnce(Return(true));
297
298 task.OnSaveVerifyResult();
299 }
300 /**
301 * @tc.name: DomainVerifierTaskSaveResultTest002
302 * @tc.desc:
303 * @tc.type: FUNC
304 */
305 HWTEST_F(DomainVerifierTaskTest, DomainVerifierTaskSaveResultTest002, TestSize.Level0)
306 {
307 AppVerifyBaseInfo appVerifyBaseInfo;
308 appVerifyBaseInfo.bundleName = "";
309 appVerifyBaseInfo.fingerprint = "";
310 appVerifyBaseInfo.appIdentifier = "";
311 SkillUri uri1;
312 uri1.scheme = "https";
313 uri1.host = "e";
314 VerifyResultInfo verifyResultInfo;
315 MocVerifyTask task(TaskType::IMMEDIATE_TASK, appVerifyBaseInfo, verifyResultInfo);
316 OHOS::NetStack::HttpClient::HttpClientResponse response;
317 response.SetResponseCode(OHOS::NetStack::HttpClient::ResponseCode::OK);
318 response.SetResult("OK");
319 std::string url = "";
320
321 EXPECT_CALL(task, SaveDomainVerifyStatus(_, _)).Times(1).WillOnce(Return(false));
322 task.OnSaveVerifyResult();
323 }
324 /**
325 * @tc.name: DomainVerifierHttpTaskTest001
326 * @tc.desc:
327 * @tc.type: FUNC
328 */
329 HWTEST_F(DomainVerifierTaskTest, DomainVerifierHttpTaskTest001, TestSize.Level0)
330 {
331 AppVerifyBaseInfo appVerifyBaseInfo;
332 appVerifyBaseInfo.bundleName = "";
333 appVerifyBaseInfo.fingerprint = "";
334 appVerifyBaseInfo.appIdentifier = "";
335 SkillUri uri1;
336 uri1.scheme = "https";
337 uri1.host = "e";
338 VerifyResultInfo verifyResultInfo;
339 std::shared_ptr<MocVerifyTask> task = std::make_shared<MocVerifyTask>(
340 TaskType::IMMEDIATE_TASK, appVerifyBaseInfo, verifyResultInfo);
341 std::shared_ptr<VerifyHttpTask> verifyHttpTask = std::make_shared<VerifyHttpTask>("", task);
342 OHOS::NetStack::HttpClient::HttpClientRequest request;
343 OHOS::NetStack::HttpClient::HttpClientResponse response;
344 OHOS::NetStack::HttpClient::HttpClientError error;
345 uint8_t* data;
346 verifyHttpTask->OnSuccess(request, response);
347 verifyHttpTask->OnFail(request, response, error);
348 verifyHttpTask->OnCancel(request, response);
349 verifyHttpTask->OnDataReceive(nullptr, request, data, 0);
350 ASSERT_TRUE(verifyHttpTask->CreateHttpClientTask() != nullptr);
351 }
352 }