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 <string>
18 #include <system_ability_definition.h>
19
20 #include "browser_proxy.h"
21 #include "bundle_mgr_host.h"
22 #include "edm_sys_manager_mock.h"
23 #include "enterprise_device_mgr_stub_mock.h"
24 #include "iservice_registry.h"
25 #include "utils.h"
26 #include "edm_log.h"
27
28 using namespace testing::ext;
29 using namespace testing;
30
31 namespace OHOS {
32 namespace EDM {
33 namespace TEST {
34 const std::string TEST_APP_ID = "test_app_id";
35 const std::string TEST_POLICY_NAME = "testPolicyName";
36 const std::string TEST_POLICY_VALUE = "testPolicyValue";
37 class BrowserProxyTest : public testing::Test {
38 protected:
39 void SetUp() override;
40
41 void TearDown() override;
42
43 static void TearDownTestSuite(void);
44 std::shared_ptr<BrowserProxy> browserProxy_ = nullptr;
45 std::shared_ptr<EdmSysManager> edmSysManager_ = nullptr;
46 sptr<EnterpriseDeviceMgrStubMock> object_ = nullptr;
47 sptr<AppExecFwk::BundleMgrHost> bundleManager_ = nullptr;
48 };
49
SetUp()50 void BrowserProxyTest::SetUp()
51 {
52 browserProxy_ = BrowserProxy::GetBrowserProxy();
53 edmSysManager_ = std::make_shared<EdmSysManager>();
54 object_ = new (std::nothrow) EnterpriseDeviceMgrStubMock();
55 edmSysManager_->RegisterSystemAbilityOfRemoteObject(ENTERPRISE_DEVICE_MANAGER_SA_ID, object_);
56
57 bundleManager_ = new (std::nothrow) AppExecFwk::BundleMgrHost();
58 edmSysManager_->RegisterSystemAbilityOfRemoteObject(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID, bundleManager_);
59 Utils::SetEdmServiceEnable();
60 }
61
TearDown()62 void BrowserProxyTest::TearDown()
63 {
64 browserProxy_.reset();
65 edmSysManager_->UnregisterSystemAbilityOfRemoteObject(ENTERPRISE_DEVICE_MANAGER_SA_ID);
66 edmSysManager_->UnregisterSystemAbilityOfRemoteObject(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
67 object_ = nullptr;
68 bundleManager_ = nullptr;
69 Utils::SetEdmServiceDisable();
70 }
71
TearDownTestSuite()72 void BrowserProxyTest::TearDownTestSuite()
73 {
74 ASSERT_FALSE(Utils::GetEdmServiceState());
75 std::cout << "EdmServiceState : " << Utils::GetEdmServiceState() << std::endl;
76 }
77
78 /**
79 * @tc.name: TestSetPolicySuc
80 * @tc.desc: Test SetPolicy success func.
81 * @tc.type: FUNC
82 */
83 HWTEST_F(BrowserProxyTest, TestSetPolicySuc, TestSize.Level1)
84 {
85 OHOS::AppExecFwk::ElementName admin;
86 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
87 .Times(1)
88 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
89 ErrCode ret = browserProxy_->SetPolicy(admin, TEST_APP_ID, TEST_POLICY_NAME, TEST_POLICY_VALUE);
90 ASSERT_TRUE(ret == ERR_OK);
91 }
92
93 /**
94 * @tc.name: TestSetPolicyFail
95 * @tc.desc: Test SetPolicy without enable edm service func.
96 * @tc.type: FUNC
97 */
98 HWTEST_F(BrowserProxyTest, TestSetPolicyFail, TestSize.Level1)
99 {
100 Utils::SetEdmServiceDisable();
101 OHOS::AppExecFwk::ElementName admin;
102 ErrCode ret = browserProxy_->SetPolicy(admin, TEST_APP_ID, TEST_POLICY_NAME, TEST_POLICY_VALUE);
103 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
104 }
105
106 /**
107 * @tc.name: TestSetPolicyParamError
108 * @tc.desc: Test SetPolicy with empty appId.
109 * @tc.type: FUNC
110 */
111 HWTEST_F(BrowserProxyTest, TestSetPolicyParamError, TestSize.Level1)
112 {
113 Utils::SetEdmServiceDisable();
114 OHOS::AppExecFwk::ElementName admin;
115 ErrCode ret = browserProxy_->SetPolicy(admin, "", TEST_POLICY_NAME, TEST_POLICY_VALUE);
116 ASSERT_TRUE(ret == EdmReturnErrCode::PARAM_ERROR);
117 }
118
119
120 /**
121 * @tc.name: TestGetPoliciesWithThreeParamsSuc
122 * @tc.desc: Test GetPolicies with three parameters success func.
123 * @tc.type: FUNC
124 */
125 HWTEST_F(BrowserProxyTest, TestGetPoliciesWithThreeParamsSuc, TestSize.Level1)
126 {
127 OHOS::AppExecFwk::ElementName admin;
128 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
129 .Times(1)
130 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestGetPolicy));
131 std::string policies;
132 ErrCode ret = browserProxy_->GetPolicies(admin, TEST_APP_ID, policies);
133 ASSERT_TRUE(ret == ERR_OK);
134 ASSERT_TRUE(policies == RETURN_STRING);
135 }
136
137 /**
138 * @tc.name: TestGetPoliciesWithThreeParamsFail
139 * @tc.desc: Test GetPolicies with three parameters without enable edm service func.
140 * @tc.type: FUNC
141 */
142 HWTEST_F(BrowserProxyTest, TestGetPoliciesWithThreeParamsFail, TestSize.Level1)
143 {
144 Utils::SetEdmServiceDisable();
145 OHOS::AppExecFwk::ElementName admin;
146 std::string policies;
147 ErrCode ret = browserProxy_->GetPolicies(admin, TEST_APP_ID, policies);
148 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
149 }
150
151 /**
152 * @tc.name: TestGetPoliciesWithTwoParamsSuc
153 * @tc.desc: Test GetPolicies with two parameters success func.
154 * @tc.type: FUNC
155 */
156 HWTEST_F(BrowserProxyTest, TestGetPoliciesWithTwoParamSuc, TestSize.Level1)
157 {
158 OHOS::AppExecFwk::ElementName admin;
159 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
160 .Times(1)
161 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestGetPolicy));
162 std::string policies;
163 ErrCode ret = browserProxy_->GetPolicies(policies);
164 ASSERT_TRUE(ret == ERR_OK);
165 ASSERT_TRUE(policies == RETURN_STRING);
166 }
167
168 /**
169 * @tc.name: TestGetPoliciesWithTwoParamsFail
170 * @tc.desc: Test GetPolicies with two parameters without enable edm service func.
171 * @tc.type: FUNC
172 */
173 HWTEST_F(BrowserProxyTest, TestGetPoliciesWithTwoParamsFail, TestSize.Level1)
174 {
175 Utils::SetEdmServiceDisable();
176 OHOS::AppExecFwk::ElementName admin;
177 std::string policies;
178 ErrCode ret = browserProxy_->GetPolicies(policies);
179 ASSERT_TRUE(ret == ERR_OK);
180 ASSERT_TRUE(policies.empty());
181 }
182
183 /**
184 * @tc.name: TestSetManagedBrowserPolicy
185 * @tc.desc: Test SetManagedBrowserPolicy success func.
186 * @tc.type: FUNC
187 */
188 HWTEST_F(BrowserProxyTest, TestSetManagedBrowserPolicySuc, TestSize.Level1)
189 {
190 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
191 .Times(1)
192 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
193 MessageParcel data;
194 ErrCode ret = browserProxy_->SetManagedBrowserPolicy(data);
195 ASSERT_TRUE(ret == ERR_OK);
196 }
197
198 /**
199 * @tc.name: TestSetManagedBrowserPolicyFail
200 * @tc.desc: Test SetManagedBrowserPolicy without enable edm service func.
201 * @tc.type: FUNC
202 */
203 HWTEST_F(BrowserProxyTest, TestSetManagedBrowserPolicyFail, TestSize.Level1)
204 {
205 Utils::SetEdmServiceDisable();
206 MessageParcel data;
207 ErrCode ret = browserProxy_->SetManagedBrowserPolicy(data);
208 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
209 }
210
211 /**
212 * @tc.name: TestGetManagedBrowserPolicySuc
213 * @tc.desc: Test GetManagedBrowserPolicy success func.
214 * @tc.type: FUNC
215 */
216 HWTEST_F(BrowserProxyTest, TestGetManagedBrowserPolicySuc, TestSize.Level1)
217 {
218 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
219 .Times(1)
220 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestGetManagedBrowserPolicy));
221 MessageParcel data;
222 void* rawData = nullptr;
223 int32_t size = -1;
224 ErrCode ret = browserProxy_->GetManagedBrowserPolicy(data, &rawData, size);
225 ASSERT_TRUE(ret == ERR_OK);
226 ASSERT_TRUE(rawData != nullptr);
227 ASSERT_TRUE(size == 200);
228 free(rawData);
229 }
230
231 /**
232 * @tc.name: TestGetManagedBrowserPolicyFail
233 * @tc.desc: Test GetManagedBrowserPolicy fail.
234 * @tc.type: FUNC
235 */
236 HWTEST_F(BrowserProxyTest, TestGetManagedBrowserPolicyFail, TestSize.Level1)
237 {
238 Utils::SetEdmServiceDisable();
239 OHOS::AppExecFwk::ElementName admin;
240 MessageParcel data;
241 void* rawData = nullptr;
242 int32_t size = -1;
243 ErrCode ret = browserProxy_->GetManagedBrowserPolicy(data, &rawData, size);
244 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
245 }
246
247 /**
248 * @tc.name: TestGetSelfManagedBrowserPolicyVersionSuc
249 * @tc.desc: Test GetSelfManagedBrowserPolicyVersion success func.
250 * @tc.type: FUNC
251 */
252 HWTEST_F(BrowserProxyTest, TestGetSelfManagedBrowserPolicyVersionSuc, TestSize.Level1)
253 {
254 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
255 .Times(1)
256 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeIntSendRequestGetPolicy));
257 MessageParcel data;
258 int32_t version = -1;
259 ErrCode ret = browserProxy_->GetSelfManagedBrowserPolicyVersion(version);
260 ASSERT_TRUE(ret == ERR_OK);
261 ASSERT_TRUE(version == 0);
262 }
263
264 /**
265 * @tc.name: TestGetSelfManagedBrowserPolicyVersionFail
266 * @tc.desc: Test GetSelfManagedBrowserPolicyVersion fail.
267 * @tc.type: FUNC
268 */
269 HWTEST_F(BrowserProxyTest, TestGetSelfManagedBrowserPolicyVersionFail, TestSize.Level1)
270 {
271 Utils::SetEdmServiceDisable();
272 OHOS::AppExecFwk::ElementName admin;
273 MessageParcel data;
274 int32_t version = -1;
275 ErrCode ret = browserProxy_->GetSelfManagedBrowserPolicyVersion(version);
276 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
277 }
278
279 /**
280 * @tc.name: TestGetSelfManagedBrowserPolicySuc
281 * @tc.desc: Test GetSelfManagedBrowserPolicy success func.
282 * @tc.type: FUNC
283 */
284 HWTEST_F(BrowserProxyTest, TestGetSelfManagedBrowserPolicySuc, TestSize.Level1)
285 {
286 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
287 .Times(1)
288 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestGetManagedBrowserPolicy));
289 MessageParcel data;
290 void* rawData = nullptr;
291 int32_t size = -1;
292 ErrCode ret = browserProxy_->GetSelfManagedBrowserPolicy(&rawData, size);
293 ASSERT_TRUE(ret == ERR_OK);
294 ASSERT_TRUE(rawData != nullptr);
295 ASSERT_TRUE(size == 200);
296 free(rawData);
297 }
298
299 /**
300 * @tc.name: TestGetSelfManagedBrowserPolicyFail
301 * @tc.desc: Test GetSelfManagedBrowserPolicy fail.
302 * @tc.type: FUNC
303 */
304 HWTEST_F(BrowserProxyTest, TestGetSelfManagedBrowserPolicyFail, TestSize.Level1)
305 {
306 Utils::SetEdmServiceDisable();
307 OHOS::AppExecFwk::ElementName admin;
308 MessageParcel data;
309 void* rawData = nullptr;
310 int32_t size = -1;
311 ErrCode ret = browserProxy_->GetSelfManagedBrowserPolicy(&rawData, size);
312 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
313 }
314 } // namespace TEST
315 } // namespace EDM
316 } // namespace OHOS
317