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 OHOS::AppExecFwk::ElementName admin;
77 admin.SetBundleName(ADMIN_PACKAGENAME);
78 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
79 .Times(1)
80 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
81 int32_t ret = deviceControlProxy->ResetFactory(admin);
82 ASSERT_TRUE(ret == ERR_OK);
83 }
84
85 /**
86 * @tc.name: TestResetFactoryFail
87 * @tc.desc: Test ResetFactory without enable edm service func.
88 * @tc.type: FUNC
89 */
90 HWTEST_F(DeviceControlProxyTest, TestResetFactoryFail, TestSize.Level1)
91 {
92 Utils::SetEdmServiceDisable();
93 OHOS::AppExecFwk::ElementName admin;
94 admin.SetBundleName(ADMIN_PACKAGENAME);
95 int32_t ret = deviceControlProxy->ResetFactory(admin);
96 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
97 }
98
99 /**
100 * @tc.name: TestTestLockScreenSuc
101 * @tc.desc: Test LockScreen success func.
102 * @tc.type: FUNC
103 */
104 HWTEST_F(DeviceControlProxyTest, TestLockScreenSuc, TestSize.Level1)
105 {
106 OHOS::AppExecFwk::ElementName admin;
107 admin.SetBundleName(ADMIN_PACKAGENAME);
108 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
109 .Times(1)
110 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
111 int32_t userId = 0;
112 AccountSA::OsAccountManager::GetOsAccountLocalIdFromProcess(userId);
113 int32_t ret = deviceControlProxy->LockScreen(admin, userId);
114 ASSERT_TRUE(ret == ERR_OK);
115 }
116
117 /**
118 * @tc.name: TestLockScreenFail
119 * @tc.desc: Test LockScreen without enable edm service func.
120 * @tc.type: FUNC
121 */
122 HWTEST_F(DeviceControlProxyTest, TestLockScreenFail, TestSize.Level1)
123 {
124 Utils::SetEdmServiceDisable();
125 OHOS::AppExecFwk::ElementName admin;
126 admin.SetBundleName(ADMIN_PACKAGENAME);
127 int32_t userId = 0;
128 AccountSA::OsAccountManager::GetOsAccountLocalIdFromProcess(userId);
129 int32_t ret = deviceControlProxy->LockScreen(admin, userId);
130 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
131 }
132
133 /**
134 * @tc.name: TestShutdownSuc
135 * @tc.desc: Test Shutdown success func.
136 * @tc.type: FUNC
137 */
138 HWTEST_F(DeviceControlProxyTest, TestShutdownSuc, TestSize.Level1)
139 {
140 OHOS::AppExecFwk::ElementName admin;
141 admin.SetBundleName(ADMIN_PACKAGENAME);
142 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
143 .Times(1)
144 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
145 int32_t ret = deviceControlProxy->Shutdown(admin);
146 ASSERT_TRUE(ret == ERR_OK);
147 }
148
149 /**
150 * @tc.name: TestShutdownFail
151 * @tc.desc: Test Shutdown without enable edm service func.
152 * @tc.type: FUNC
153 */
154 HWTEST_F(DeviceControlProxyTest, TestShutdownFail, TestSize.Level1)
155 {
156 Utils::SetEdmServiceDisable();
157 OHOS::AppExecFwk::ElementName admin;
158 admin.SetBundleName(ADMIN_PACKAGENAME);
159 int32_t ret = deviceControlProxy->Shutdown(admin);
160 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
161 }
162
163 /**
164 * @tc.name: TestRebootSuc
165 * @tc.desc: Test Reboot success func.
166 * @tc.type: FUNC
167 */
168 HWTEST_F(DeviceControlProxyTest, TestRebootSuc, TestSize.Level1)
169 {
170 OHOS::AppExecFwk::ElementName admin;
171 admin.SetBundleName(ADMIN_PACKAGENAME);
172 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
173 .Times(1)
174 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
175 int32_t ret = deviceControlProxy->Reboot(admin);
176 ASSERT_TRUE(ret == ERR_OK);
177 }
178
179 /**
180 * @tc.name: TestRebootFail
181 * @tc.desc: Test Reboot without enable edm service func.
182 * @tc.type: FUNC
183 */
184 HWTEST_F(DeviceControlProxyTest, TestRebootFail, TestSize.Level1)
185 {
186 Utils::SetEdmServiceDisable();
187 OHOS::AppExecFwk::ElementName admin;
188 admin.SetBundleName(ADMIN_PACKAGENAME);
189 int32_t ret = deviceControlProxy->Reboot(admin);
190 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
191 }
192
193 /**
194 * @tc.name: TestOperateDeviceFail
195 * @tc.desc: Test OperateDevice without enable edm service func.
196 * @tc.type: FUNC
197 */
198 HWTEST_F(DeviceControlProxyTest, TestOperateDeviceFail, TestSize.Level1)
199 {
200 Utils::SetEdmServiceDisable();
201 OHOS::AppExecFwk::ElementName admin;
202 admin.SetBundleName(ADMIN_PACKAGENAME);
203 OperateDeviceParam param{EdmConstants::DeviceControl::RESET_FACTORY, "", 0};
204 int32_t ret = deviceControlProxy->OperateDevice(admin, param);
205 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
206 }
207
208 /**
209 * @tc.name: TestOperateDeviceSuc
210 * @tc.desc: Test OperateDevice success func.
211 * @tc.type: FUNC
212 */
213 HWTEST_F(DeviceControlProxyTest, TestOperateDeviceSuc, TestSize.Level1)
214 {
215 OHOS::AppExecFwk::ElementName admin;
216 admin.SetBundleName(ADMIN_PACKAGENAME);
217 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
218 .Times(1)
219 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
220 OperateDeviceParam param{EdmConstants::DeviceControl::RESET_FACTORY, "", 0};
221 int32_t ret = deviceControlProxy->OperateDevice(admin, param);
222 ASSERT_TRUE(ret == ERR_OK);
223 }
224 } // namespace TEST
225 } // namespace EDM
226 } // namespace OHOS
227