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 
16 #include <gtest/gtest.h>
17 #include <memory>
18 #include <string>
19 #include "mock_verify_agent.h"
20 #include "app_domain_verify_agent_service_proxy.h"
21 #include "refbase.h"
22 #include "mock_constant.h"
23 #include "mock_verify_mgr.h"
24 #include "app_domain_verify_mgr_interface_code.h"
25 #define private public
26 #define protected public
27 #include "app_domain_verify_mgr_client.h"
28 #include "app_domain_verify_agent_client.h"
29 #include "app_domain_verify_mgr_service.h"
30 #undef private
31 #undef protected
32 #include "mock_access_token.h"
33 
34 namespace OHOS::AppDomainVerify {
35 using ::testing::_;
36 using ::testing::Invoke;
37 using ::testing::Mock;
38 using namespace testing;
39 using namespace testing::ext;
40 class AppDomainVerifyMgrModuleTest : public testing::Test {
41 public:
42     static void SetUpTestCase(void);
43     static void TearDownTestCase(void);
44     void SetUp();
45     void TearDown();
46 };
47 auto appDomainVerifyMgrService_ = std::make_shared<AppDomainVerifyMgrService>();
48 auto appDomainVerifyAgentStubMock_ = std::make_shared<AppDomainVerifyAgentRemoteStubMock>();
InvokeSingleVerifyOK(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)49 int InvokeSingleVerifyOK(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
50 {
51     APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MODULE_BUTT, "call end");
52     std::string bundleName = BUNDLE_NAME;
53     VerifyResultInfo verifyResultInfo;
54     verifyResultInfo.hostVerifyStatusMap.insert_or_assign(
55         "https://" + HOST, std::make_tuple(InnerVerifyStatus::STATE_SUCCESS, std::string(), 0));
56     appDomainVerifyMgrService_->SaveDomainVerifyStatus(bundleName, verifyResultInfo);
57     return 0;
58 }
59 
InvokeSingleVerifyFail(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)60 int InvokeSingleVerifyFail(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
61 {
62     APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MODULE_BUTT, "call end");
63     std::string bundleName = BUNDLE_NAME;
64     VerifyResultInfo verifyResultInfo;
65     verifyResultInfo.hostVerifyStatusMap.insert_or_assign(
66         "https://" + HOST, std::make_tuple(InnerVerifyStatus::STATE_FAIL, std::string(), 0));
67     appDomainVerifyMgrService_->SaveDomainVerifyStatus(bundleName, verifyResultInfo);
68     return UNKNOWN_ERROR;
69 }
70 
SetUpTestCase(void)71 void AppDomainVerifyMgrModuleTest::SetUpTestCase(void)
72 {
73 }
74 
TearDownTestCase(void)75 void AppDomainVerifyMgrModuleTest::TearDownTestCase(void)
76 {
77     appDomainVerifyMgrService_.reset();
78     appDomainVerifyAgentStubMock_.reset();
79 }
80 
SetUp(void)81 void AppDomainVerifyMgrModuleTest::SetUp(void)
82 {
83     MockAccessToken::mockSA();
84     AppDomainVerifyAgentClient::staticDestoryMonitor_.destoryed_ = true;
85 }
86 
TearDown(void)87 void AppDomainVerifyMgrModuleTest::TearDown(void)
88 {
89 }
90 /**
91  * @tc.name: AppDomainVerifyMgrModuleTest001
92  * @tc.desc: VerifyDomain ok test.
93  * @tc.type: FUNC
94  */
95 HWTEST_F(AppDomainVerifyMgrModuleTest, AppDomainVerifyMgrModuleTest001, TestSize.Level0)
96 {
97     EXPECT_CALL(*appDomainVerifyAgentStubMock_, SendRequest(_, _, _, _))
98         .Times(1)
99         .WillOnce(::testing::Invoke(InvokeSingleVerifyOK));
100     AppDomainVerifyAgentClient::agentServiceProxy_ = sptr<AppDomainVerifyAgentServiceProxy>::MakeSptr(
101         appDomainVerifyAgentStubMock_.get());
102     std::vector<SkillUri> skillUris;
103     SkillUri skillUri;
104     skillUri.scheme = "https";
105     skillUri.host = HOST;
106     skillUris.emplace_back(skillUri);
107     appDomainVerifyMgrService_->VerifyDomain(APP_IDENTIFIER, BUNDLE_NAME, FINGERPRINT, skillUris);
108     DomainVerifyStatus domainVerificationState;
109     auto queryRes = appDomainVerifyMgrService_->QueryDomainVerifyStatus(BUNDLE_NAME, domainVerificationState);
110     ASSERT_TRUE(queryRes);
111     ASSERT_TRUE(domainVerificationState == DomainVerifyStatus::STATE_VERIFIED);
112 }
113 
114 /**
115  * @tc.name: AppDomainVerifyMgrModuleTest002
116  * @tc.desc: VerifyDomain fail test.
117  * @tc.type: FUNC
118  */
119 HWTEST_F(AppDomainVerifyMgrModuleTest, AppDomainVerifyMgrModuleTest002, TestSize.Level0)
120 {
121     EXPECT_CALL(*appDomainVerifyAgentStubMock_, SendRequest(_, _, _, _))
122         .Times(1)
123         .WillOnce(::testing::Invoke(InvokeSingleVerifyFail));
124     AppDomainVerifyAgentClient::agentServiceProxy_ = sptr<AppDomainVerifyAgentServiceProxy>::MakeSptr(
125         appDomainVerifyAgentStubMock_.get());
126 
127     std::vector<SkillUri> skillUris;
128     SkillUri skillUri;
129     skillUri.scheme = "https";
130     skillUri.host = HOST;
131     skillUris.emplace_back(skillUri);
132     appDomainVerifyMgrService_->VerifyDomain(APP_IDENTIFIER, BUNDLE_NAME, FINGERPRINT, skillUris);
133     DomainVerifyStatus domainVerificationState;
134     auto queryRes = appDomainVerifyMgrService_->QueryDomainVerifyStatus(BUNDLE_NAME, domainVerificationState);
135     ASSERT_TRUE(queryRes);
136     ASSERT_TRUE(domainVerificationState == DomainVerifyStatus::STATE_NONE);
137 }
138 
139 /**
140  * @tc.name: AppDomainVerifyMgrModuleTest003
141  * @tc.desc: FilterAbilities ok test.
142  * @tc.type: FUNC
143  */
144 HWTEST_F(AppDomainVerifyMgrModuleTest, AppDomainVerifyMgrModuleTest003, TestSize.Level0)
145 {
146     EXPECT_CALL(*appDomainVerifyAgentStubMock_, SendRequest(_, _, _, _))
147         .Times(1)
148         .WillOnce(::testing::Invoke(InvokeSingleVerifyOK));
149     AppDomainVerifyAgentClient::agentServiceProxy_ = sptr<AppDomainVerifyAgentServiceProxy>::MakeSptr(
150         appDomainVerifyAgentStubMock_.get());
151 
152     std::vector<SkillUri> skillUris;
153     SkillUri skillUri;
154     skillUri.scheme = "https";
155     skillUri.host = HOST;
156     skillUris.emplace_back(skillUri);
157     appDomainVerifyMgrService_->VerifyDomain(APP_IDENTIFIER, BUNDLE_NAME, FINGERPRINT, skillUris);
158     OHOS::AAFwk::Want want;
159     want.SetUri("https://" + HOST);
160     OHOS::AppExecFwk::AbilityInfo abilityInfo;
161     abilityInfo.bundleName = BUNDLE_NAME;
162     std::vector<OHOS::AppExecFwk::AbilityInfo> originAbilityInfos;
163     originAbilityInfos.emplace_back(abilityInfo);
164     std::vector<OHOS::AppExecFwk::AbilityInfo> filtedAbilityInfos;
165     auto filterRes = appDomainVerifyMgrService_->FilterAbilities(want, originAbilityInfos, filtedAbilityInfos);
166     ASSERT_TRUE(filterRes);
167     ASSERT_TRUE(!filtedAbilityInfos.empty());
168     ASSERT_TRUE(filtedAbilityInfos[0].bundleName == BUNDLE_NAME);
169 }
170 
171 /**
172  * @tc.name: AppDomainVerifyMgrModuleTest004
173  * @tc.desc: FilterAbilities fail test.
174  * @tc.type: FUNC
175  */
176 HWTEST_F(AppDomainVerifyMgrModuleTest, AppDomainVerifyMgrModuleTest004, TestSize.Level0)
177 {
178     EXPECT_CALL(*appDomainVerifyAgentStubMock_, SendRequest(_, _, _, _))
179         .Times(1)
180         .WillOnce(::testing::Invoke(InvokeSingleVerifyFail));
181     AppDomainVerifyAgentClient::agentServiceProxy_ = sptr<AppDomainVerifyAgentServiceProxy>::MakeSptr(
182         appDomainVerifyAgentStubMock_.get());
183     std::vector<SkillUri> skillUris;
184     SkillUri skillUri;
185     skillUri.scheme = "https";
186     skillUri.host = HOST;
187     skillUris.emplace_back(skillUri);
188     appDomainVerifyMgrService_->VerifyDomain(APP_IDENTIFIER, BUNDLE_NAME, FINGERPRINT, skillUris);
189 
190     OHOS::AAFwk::Want want;
191     want.SetUri("https://" + HOST);
192     OHOS::AppExecFwk::AbilityInfo abilityInfo;
193     abilityInfo.bundleName = BUNDLE_NAME;
194     std::vector<OHOS::AppExecFwk::AbilityInfo> originAbilityInfos;
195     originAbilityInfos.emplace_back(abilityInfo);
196 
197     std::vector<OHOS::AppExecFwk::AbilityInfo> filtedAbilityInfos;
198     auto filterRes = appDomainVerifyMgrService_->FilterAbilities(want, originAbilityInfos, filtedAbilityInfos);
199     ASSERT_TRUE(filterRes);
200     ASSERT_TRUE(filtedAbilityInfos.empty());
201 }
202 
203 /**
204  * @tc.name: AppDomainVerifyMgrModuleTest005
205  * @tc.desc: FilterAbilities fail test.
206  * @tc.type: FUNC
207  */
208 HWTEST_F(AppDomainVerifyMgrModuleTest, AppDomainVerifyMgrModuleTest005, TestSize.Level0)
209 {
210     OHOS::AAFwk::Want want;
211     want.SetElementName(BUNDLE_NAME, "MainAbility");
212     want.SetUri("https://" + HOST);
213     OHOS::AppExecFwk::AbilityInfo abilityInfo;
214     abilityInfo.bundleName = BUNDLE_NAME;
215     std::vector<OHOS::AppExecFwk::AbilityInfo> originAbilityInfos;
216     originAbilityInfos.emplace_back(abilityInfo);
217 
218     std::vector<OHOS::AppExecFwk::AbilityInfo> filtedAbilityInfos;
219     auto filterRes = appDomainVerifyMgrService_->FilterAbilities(want, originAbilityInfos, filtedAbilityInfos);
220     ASSERT_FALSE(filterRes);
221     ASSERT_TRUE(filtedAbilityInfos.empty());
222 }
223 
224 /**
225  * @tc.name: AppDomainVerifyMgrModuleTest006
226  * @tc.desc: QueryDomainVerifyStatus test.
227  * @tc.type: FUNC
228  */
229 HWTEST_F(AppDomainVerifyMgrModuleTest, AppDomainVerifyMgrModuleTest006, TestSize.Level0)
230 {
231     DomainVerifyStatus domainVerificationState;
232     auto queryRes = appDomainVerifyMgrService_->QueryDomainVerifyStatus(BUNDLE_NAME, domainVerificationState);
233     ASSERT_TRUE(queryRes);
234     ASSERT_TRUE(domainVerificationState == DomainVerifyStatus::STATE_NONE);
235 }
236 }
237