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 "device_control_proxy.h"
21 #include "edm_constants.h"
22 #include "edm_sys_manager_mock.h"
23 #include "enterprise_device_mgr_stub_mock.h"
24 #include "utils.h"
25 #include "os_account_manager.h"
26
27 using namespace testing::ext;
28 using namespace testing;
29
30 namespace OHOS {
31 namespace EDM {
32 namespace TEST {
33 const std::string ADMIN_PACKAGENAME = "com.edm.test.demo";
34 class DeviceControlProxyTest : public testing::Test {
35 protected:
36 void SetUp() override;
37
38 void TearDown() override;
39
40 static void TearDownTestSuite(void);
41 std::shared_ptr<DeviceControlProxy> deviceControlProxy = nullptr;
42 std::shared_ptr<EdmSysManager> edmSysManager_ = nullptr;
43 sptr<EnterpriseDeviceMgrStubMock> object_ = nullptr;
44 };
45
SetUp()46 void DeviceControlProxyTest::SetUp()
47 {
48 deviceControlProxy = DeviceControlProxy::GetDeviceControlProxy();
49 edmSysManager_ = std::make_shared<EdmSysManager>();
50 object_ = new (std::nothrow) EnterpriseDeviceMgrStubMock();
51 edmSysManager_->RegisterSystemAbilityOfRemoteObject(ENTERPRISE_DEVICE_MANAGER_SA_ID, object_);
52 Utils::SetEdmServiceEnable();
53 }
54
TearDown()55 void DeviceControlProxyTest::TearDown()
56 {
57 deviceControlProxy.reset();
58 edmSysManager_->UnregisterSystemAbilityOfRemoteObject(ENTERPRISE_DEVICE_MANAGER_SA_ID);
59 object_ = nullptr;
60 Utils::SetEdmServiceDisable();
61 }
62
TearDownTestSuite()63 void DeviceControlProxyTest::TearDownTestSuite()
64 {
65 ASSERT_FALSE(Utils::GetEdmServiceState());
66 std::cout << "EdmServiceState : " << Utils::GetEdmServiceState() << std::endl;
67 }
68
69 /**
70 * @tc.name: TestResetFactorySuc
71 * @tc.desc: Test ResetFactory success func.
72 * @tc.type: FUNC
73 */
74 HWTEST_F(DeviceControlProxyTest, TestResetFactorySuc, TestSize.Level1)
75 {
76 MessageParcel data;
77 OHOS::AppExecFwk::ElementName admin;
78 admin.SetBundleName(ADMIN_PACKAGENAME);
79 data.WriteParcelable(&admin);
80 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
81 .Times(1)
82 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
83 int32_t ret = deviceControlProxy->ResetFactory(data);
84 ASSERT_TRUE(ret == ERR_OK);
85 }
86
87 /**
88 * @tc.name: TestResetFactoryFail
89 * @tc.desc: Test ResetFactory without enable edm service func.
90 * @tc.type: FUNC
91 */
92 HWTEST_F(DeviceControlProxyTest, TestResetFactoryFail, TestSize.Level1)
93 {
94 Utils::SetEdmServiceDisable();
95 MessageParcel data;
96 OHOS::AppExecFwk::ElementName admin;
97 admin.SetBundleName(ADMIN_PACKAGENAME);
98 data.WriteParcelable(&admin);
99 int32_t ret = deviceControlProxy->ResetFactory(data);
100 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
101 }
102
103 /**
104 * @tc.name: TestTestLockScreenSuc
105 * @tc.desc: Test LockScreen success func.
106 * @tc.type: FUNC
107 */
108 HWTEST_F(DeviceControlProxyTest, TestLockScreenSuc, TestSize.Level1)
109 {
110 OHOS::AppExecFwk::ElementName admin;
111 admin.SetBundleName(ADMIN_PACKAGENAME);
112 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
113 .Times(1)
114 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
115 int32_t userId = 0;
116 AccountSA::OsAccountManager::GetOsAccountLocalIdFromProcess(userId);
117 int32_t ret = deviceControlProxy->LockScreen(admin, userId);
118 ASSERT_TRUE(ret == ERR_OK);
119 }
120
121 /**
122 * @tc.name: TestLockScreenFail
123 * @tc.desc: Test LockScreen without enable edm service func.
124 * @tc.type: FUNC
125 */
126 HWTEST_F(DeviceControlProxyTest, TestLockScreenFail, TestSize.Level1)
127 {
128 Utils::SetEdmServiceDisable();
129 OHOS::AppExecFwk::ElementName admin;
130 admin.SetBundleName(ADMIN_PACKAGENAME);
131 int32_t userId = 0;
132 AccountSA::OsAccountManager::GetOsAccountLocalIdFromProcess(userId);
133 int32_t ret = deviceControlProxy->LockScreen(admin, userId);
134 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
135 }
136
137 /**
138 * @tc.name: TestShutdownSuc
139 * @tc.desc: Test Shutdown success func.
140 * @tc.type: FUNC
141 */
142 HWTEST_F(DeviceControlProxyTest, TestShutdownSuc, TestSize.Level1)
143 {
144 MessageParcel data;
145 OHOS::AppExecFwk::ElementName admin;
146 admin.SetBundleName(ADMIN_PACKAGENAME);
147 data.WriteParcelable(&admin);
148 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
149 .Times(1)
150 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
151 int32_t ret = deviceControlProxy->Shutdown(data);
152 ASSERT_TRUE(ret == ERR_OK);
153 }
154
155 /**
156 * @tc.name: TestShutdownFail
157 * @tc.desc: Test Shutdown without enable edm service func.
158 * @tc.type: FUNC
159 */
160 HWTEST_F(DeviceControlProxyTest, TestShutdownFail, TestSize.Level1)
161 {
162 Utils::SetEdmServiceDisable();
163 MessageParcel data;
164 OHOS::AppExecFwk::ElementName admin;
165 admin.SetBundleName(ADMIN_PACKAGENAME);
166 data.WriteParcelable(&admin);
167 int32_t ret = deviceControlProxy->Shutdown(data);
168 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
169 }
170
171 /**
172 * @tc.name: TestRebootSuc
173 * @tc.desc: Test Reboot success func.
174 * @tc.type: FUNC
175 */
176 HWTEST_F(DeviceControlProxyTest, TestRebootSuc, TestSize.Level1)
177 {
178 MessageParcel data;
179 OHOS::AppExecFwk::ElementName admin;
180 admin.SetBundleName(ADMIN_PACKAGENAME);
181 data.WriteParcelable(&admin);
182 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
183 .Times(1)
184 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
185 int32_t ret = deviceControlProxy->Reboot(data);
186 ASSERT_TRUE(ret == ERR_OK);
187 }
188
189 /**
190 * @tc.name: TestRebootFail
191 * @tc.desc: Test Reboot without enable edm service func.
192 * @tc.type: FUNC
193 */
194 HWTEST_F(DeviceControlProxyTest, TestRebootFail, TestSize.Level1)
195 {
196 Utils::SetEdmServiceDisable();
197 MessageParcel data;
198 OHOS::AppExecFwk::ElementName admin;
199 admin.SetBundleName(ADMIN_PACKAGENAME);
200 data.WriteParcelable(&admin);
201 int32_t ret = deviceControlProxy->Reboot(data);
202 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
203 }
204
205 /**
206 * @tc.name: TestOperateDeviceFail
207 * @tc.desc: Test OperateDevice without enable edm service func.
208 * @tc.type: FUNC
209 */
210 HWTEST_F(DeviceControlProxyTest, TestOperateDeviceFail, TestSize.Level1)
211 {
212 Utils::SetEdmServiceDisable();
213 OHOS::AppExecFwk::ElementName admin;
214 admin.SetBundleName(ADMIN_PACKAGENAME);
215 OperateDeviceParam param{EdmConstants::DeviceControl::RESET_FACTORY, "", 0};
216 int32_t ret = deviceControlProxy->OperateDevice(admin, param);
217 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
218 }
219
220 /**
221 * @tc.name: TestOperateDeviceSuc
222 * @tc.desc: Test OperateDevice success func.
223 * @tc.type: FUNC
224 */
225 HWTEST_F(DeviceControlProxyTest, TestOperateDeviceSuc, TestSize.Level1)
226 {
227 OHOS::AppExecFwk::ElementName admin;
228 admin.SetBundleName(ADMIN_PACKAGENAME);
229 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
230 .Times(1)
231 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
232 OperateDeviceParam param{EdmConstants::DeviceControl::RESET_FACTORY, "", 0};
233 int32_t ret = deviceControlProxy->OperateDevice(admin, param);
234 ASSERT_TRUE(ret == ERR_OK);
235 }
236 } // namespace TEST
237 } // namespace EDM
238 } // namespace OHOS
239