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 }
174 
175 /**
176  * @tc.name: DomainVerifierTaskTest005
177  * @tc.desc:
178  * @tc.type: FUNC
179  */
180 HWTEST_F(DomainVerifierTaskTest, DomainVerifierTaskTest005, TestSize.Level0)
181 {
182     AppVerifyBaseInfo appVerifyBaseInfo;
183     appVerifyBaseInfo.bundleName = "";
184     appVerifyBaseInfo.fingerprint = "";
185     appVerifyBaseInfo.appIdentifier = "";
186     SkillUri uri1;
187     uri1.scheme = "https";
188     uri1.host = "e";
189     VerifyResultInfo verifyResultInfo;
190     VerifyTask task(TaskType::IMMEDIATE_TASK, appVerifyBaseInfo, verifyResultInfo);
191     OHOS::NetStack::HttpClient::HttpClientResponse response;
192     response.SetResponseCode(OHOS::NetStack::HttpClient::ResponseCode::OK);
193     response.SetResult("OK");
194     std::string url = "test1";
195     task.UpdateVerifyResultInfo(url, FAILURE_CLIENT_ERROR);
196     auto hostVerifyStatusMap = task.GetUriVerifyMap();
197     ASSERT_TRUE(hostVerifyStatusMap.find(url) != hostVerifyStatusMap.end());
198     InnerVerifyStatus status;
199     std::string verifyTime;
200     int verifyCnt = 0;
201     std::tie(status, verifyTime, verifyCnt) = hostVerifyStatusMap.at(url);
202     ASSERT_EQ(status, FAILURE_CLIENT_ERROR);
203     ASSERT_EQ(verifyCnt, 0);
204     task.UpdateVerifyResultInfo(url, FAILURE_CLIENT_ERROR);
205     hostVerifyStatusMap = task.GetUriVerifyMap();
206     std::tie(status, verifyTime, verifyCnt) = hostVerifyStatusMap.at(url);
207     ASSERT_EQ(status, FAILURE_CLIENT_ERROR);
208     ASSERT_EQ(verifyCnt, 1);
209     task.UpdateVerifyResultInfo(url, FAILURE_HTTP_UNKNOWN);
210     hostVerifyStatusMap = task.GetUriVerifyMap();
211     std::tie(status, verifyTime, verifyCnt) = hostVerifyStatusMap.at(url);
212     ASSERT_EQ(status, FAILURE_HTTP_UNKNOWN);
213     ASSERT_EQ(verifyCnt, 0);
214 }
215 
216 /**
217  * @tc.name: DomainVerifierTaskTest006
218  * @tc.desc:
219  * @tc.type: FUNC
220  */
221 HWTEST_F(DomainVerifierTaskTest, DomainVerifierTaskTest006, TestSize.Level0)
222 {
223     AppVerifyBaseInfo appVerifyBaseInfo;
224     appVerifyBaseInfo.bundleName = "";
225     appVerifyBaseInfo.fingerprint = "";
226     appVerifyBaseInfo.appIdentifier = "";
227     SkillUri uri1;
228     uri1.scheme = "https";
229     uri1.host = "e";
230     VerifyResultInfo verifyResultInfo;
231     VerifyTask task(TaskType::IMMEDIATE_TASK, appVerifyBaseInfo, verifyResultInfo);
232     std::tuple<InnerVerifyStatus, std::string, int> info;
233     std::get<0>(info) = FAILURE_CLIENT_ERROR;
234     std::get<1>(info) = std::to_string(GetSecondsSince1970ToNow());
235     std::get<2>(info) = 1;
236     ASSERT_FALSE(task.IsNeedRetry(info));
237     std::get<1>(info) = std::to_string(GetSecondsSince1970ToNow() - 3600 * 5);
238     ASSERT_TRUE(task.IsNeedRetry(info));
239     std::get<1>(info) = std::to_string(GetSecondsSince1970ToNow() - 3600 * 1);
240     ASSERT_FALSE(task.IsNeedRetry(info));
241     std::get<1>(info) = std::to_string(GetSecondsSince1970ToNow() - 3600 * 3);
242     std::get<2>(info) = 2;
243     ASSERT_FALSE(task.IsNeedRetry(info));
244     std::get<0>(info) = FAILURE_HTTP_UNKNOWN;
245     ASSERT_TRUE(task.IsNeedRetry(info));
246     std::get<0>(info) = STATE_SUCCESS;
247     ASSERT_FALSE(task.IsNeedRetry(info));
248     std::get<0>(info) = FORBIDDEN_FOREVER;
249     ASSERT_FALSE(task.IsNeedRetry(info));
250 }
251 
252 /**
253  * @tc.name: DomainVerifierTaskTest007
254  * @tc.desc:
255  * @tc.type: FUNC
256  */
257 HWTEST_F(DomainVerifierTaskTest, DomainVerifierTaskTest007, TestSize.Level0)
258 {
259     AppVerifyBaseInfo appVerifyBaseInfo;
260     appVerifyBaseInfo.bundleName = "";
261     appVerifyBaseInfo.fingerprint = "";
262     appVerifyBaseInfo.appIdentifier = "";
263     SkillUri uri1;
264     uri1.scheme = "https";
265     uri1.host = "e";
266     VerifyResultInfo verifyResultInfo;
267     VerifyTask task(TaskType::IMMEDIATE_TASK, appVerifyBaseInfo, verifyResultInfo);
268     int64_t time = task.CalcRetryDuration(0);
269     ASSERT_EQ(time, 3600);
270     time = task.CalcRetryDuration(7);
271     ASSERT_EQ(time, 460800);
272 }
273 
274 /**
275  * @tc.name: DomainVerifierTaskSaveResultTest001
276  * @tc.desc:
277  * @tc.type: FUNC
278  */
279 HWTEST_F(DomainVerifierTaskTest, DomainVerifierTaskSaveResultTest001, TestSize.Level0)
280 {
281     AppVerifyBaseInfo appVerifyBaseInfo;
282     appVerifyBaseInfo.bundleName = "";
283     appVerifyBaseInfo.fingerprint = "";
284     appVerifyBaseInfo.appIdentifier = "";
285     SkillUri uri1;
286     uri1.scheme = "https";
287     uri1.host = "e";
288     VerifyResultInfo verifyResultInfo;
289     MocVerifyTask task(TaskType::IMMEDIATE_TASK, appVerifyBaseInfo, verifyResultInfo);
290     OHOS::NetStack::HttpClient::HttpClientResponse response;
291     response.SetResponseCode(OHOS::NetStack::HttpClient::ResponseCode::OK);
292     response.SetResult("OK");
293     std::string url = "";
294 
295     EXPECT_CALL(task, SaveDomainVerifyStatus(_, _)).Times(1).WillOnce(Return(true));
296 
297     task.OnSaveVerifyResult();
298 }
299 /**
300  * @tc.name: DomainVerifierTaskSaveResultTest002
301  * @tc.desc:
302  * @tc.type: FUNC
303  */
304 HWTEST_F(DomainVerifierTaskTest, DomainVerifierTaskSaveResultTest002, TestSize.Level0)
305 {
306     AppVerifyBaseInfo appVerifyBaseInfo;
307     appVerifyBaseInfo.bundleName = "";
308     appVerifyBaseInfo.fingerprint = "";
309     appVerifyBaseInfo.appIdentifier = "";
310     SkillUri uri1;
311     uri1.scheme = "https";
312     uri1.host = "e";
313     VerifyResultInfo verifyResultInfo;
314     MocVerifyTask task(TaskType::IMMEDIATE_TASK, appVerifyBaseInfo, verifyResultInfo);
315     OHOS::NetStack::HttpClient::HttpClientResponse response;
316     response.SetResponseCode(OHOS::NetStack::HttpClient::ResponseCode::OK);
317     response.SetResult("OK");
318     std::string url = "";
319 
320     EXPECT_CALL(task, SaveDomainVerifyStatus(_, _)).Times(1).WillOnce(Return(false));
321     task.OnSaveVerifyResult();
322 }
323 /**
324  * @tc.name: DomainVerifierHttpTaskTest001
325  * @tc.desc:
326  * @tc.type: FUNC
327  */
328 HWTEST_F(DomainVerifierTaskTest, DomainVerifierHttpTaskTest001, TestSize.Level0)
329 {
330     AppVerifyBaseInfo appVerifyBaseInfo;
331     appVerifyBaseInfo.bundleName = "";
332     appVerifyBaseInfo.fingerprint = "";
333     appVerifyBaseInfo.appIdentifier = "";
334     SkillUri uri1;
335     uri1.scheme = "https";
336     uri1.host = "e";
337     VerifyResultInfo verifyResultInfo;
338     std::shared_ptr<MocVerifyTask> task = std::make_shared<MocVerifyTask>(
339         TaskType::IMMEDIATE_TASK, appVerifyBaseInfo, verifyResultInfo);
340     std::shared_ptr<VerifyHttpTask> verifyHttpTask = std::make_shared<VerifyHttpTask>("", task);
341     OHOS::NetStack::HttpClient::HttpClientRequest request;
342     OHOS::NetStack::HttpClient::HttpClientResponse response;
343     OHOS::NetStack::HttpClient::HttpClientError error;
344     uint8_t* data;
345     verifyHttpTask->OnSuccess(request, response);
346     verifyHttpTask->OnFail(request, response, error);
347     verifyHttpTask->OnCancel(request, response);
348     verifyHttpTask->OnDataReceive(nullptr, request, data, 0);
349     ASSERT_TRUE(verifyHttpTask->CreateHttpClientTask() != nullptr);
350 }
351 }