1 /*
2 * Copyright (c) 2025 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 "telephony_manager_proxy.h"
17
18 #include <gtest/gtest.h>
19 #include <system_ability_definition.h>
20
21 #include <string>
22 #include <vector>
23
24 #include "edm_sys_manager_mock.h"
25 #include "enterprise_device_mgr_stub_mock.h"
26 #include "utils.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 ADMIN_PACKAGENAME = "com.edm.test.demo";
35 class TelephonyManagerProxyTest : public testing::Test {
36 protected:
37 void SetUp() override;
38
39 void TearDown() override;
40
41 static void TearDownTestSuite(void);
42 std::shared_ptr<TelephonyManagerProxy> telephonyManagerProxy = nullptr;
43 std::shared_ptr<EdmSysManager> edmSysManager_ = nullptr;
44 sptr<EnterpriseDeviceMgrStubMock> object_ = nullptr;
45 };
46
SetUp()47 void TelephonyManagerProxyTest::SetUp()
48 {
49 telephonyManagerProxy = TelephonyManagerProxy::GetTelephonyManagerProxy();
50 edmSysManager_ = std::make_shared<EdmSysManager>();
51 object_ = new (std::nothrow) EnterpriseDeviceMgrStubMock();
52 edmSysManager_->RegisterSystemAbilityOfRemoteObject(ENTERPRISE_DEVICE_MANAGER_SA_ID, object_);
53 Utils::SetEdmServiceEnable();
54 }
55
TearDown()56 void TelephonyManagerProxyTest::TearDown()
57 {
58 telephonyManagerProxy.reset();
59 edmSysManager_->UnregisterSystemAbilityOfRemoteObject(ENTERPRISE_DEVICE_MANAGER_SA_ID);
60 object_ = nullptr;
61 Utils::SetEdmServiceDisable();
62 }
63
TearDownTestSuite()64 void TelephonyManagerProxyTest::TearDownTestSuite()
65 {
66 ASSERT_FALSE(Utils::GetEdmServiceState());
67 std::cout << "EdmServiceState : " << Utils::GetEdmServiceState() << std::endl;
68 }
69
70 /**
71 * @tc.name: TestSetSimDisabledSuc
72 * @tc.desc: Test SetSimDisabled func.
73 * @tc.type: FUNC
74 */
75 HWTEST_F(TelephonyManagerProxyTest, TestSetSimDisabledSuc, TestSize.Level1)
76 {
77 MessageParcel data;
78 OHOS::AppExecFwk::ElementName admin;
79 admin.SetBundleName(ADMIN_PACKAGENAME);
80 data.WriteParcelable(&admin);
81 data.WriteInt32(0);
82 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
83 .Times(1)
84 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
85
86 int32_t ret = telephonyManagerProxy->SetSimDisabled(data);
87 ASSERT_TRUE(ret == ERR_OK);
88 }
89
90 /**
91 * @tc.name: TestSetSimDisabledFail
92 * @tc.desc: Test SetSimDisabled func.
93 * @tc.type: FUNC
94 */
95 HWTEST_F(TelephonyManagerProxyTest, TestSetSimDisabledFail, TestSize.Level1)
96 {
97 Utils::SetEdmServiceDisable();
98 MessageParcel data;
99 OHOS::AppExecFwk::ElementName admin;
100 admin.SetBundleName(ADMIN_PACKAGENAME);
101 data.WriteParcelable(&admin);
102 data.WriteInt32(0);
103 int32_t ret = telephonyManagerProxy->SetSimDisabled(data);
104 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
105 }
106
107 /**
108 * @tc.name: TestSetSimEnabledSuc
109 * @tc.desc: Test SetSimEnabled func.
110 * @tc.type: FUNC
111 */
112 HWTEST_F(TelephonyManagerProxyTest, TestSetSimEnabledSuc, TestSize.Level1)
113 {
114 MessageParcel data;
115 OHOS::AppExecFwk::ElementName admin;
116 admin.SetBundleName(ADMIN_PACKAGENAME);
117 data.WriteParcelable(&admin);
118 data.WriteInt32(0);
119 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
120 .Times(1)
121 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
122
123 int32_t ret = telephonyManagerProxy->SetSimEnabled(data);
124 ASSERT_TRUE(ret == ERR_OK);
125 }
126
127 /**
128 * @tc.name: TestSetSimEnabledFail
129 * @tc.desc: Test SetSimEnabled func.
130 * @tc.type: FUNC
131 */
132 HWTEST_F(TelephonyManagerProxyTest, TestSetSimEnabledFail, TestSize.Level1)
133 {
134 Utils::SetEdmServiceDisable();
135 MessageParcel data;
136 OHOS::AppExecFwk::ElementName admin;
137 admin.SetBundleName(ADMIN_PACKAGENAME);
138 data.WriteParcelable(&admin);
139 data.WriteInt32(0);
140 int32_t ret = telephonyManagerProxy->SetSimEnabled(data);
141 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
142 }
143
144 /**
145 * @tc.name: TestIsSimDisabledSuc
146 * @tc.desc: Test IsSimDisabled func.
147 * @tc.type: FUNC
148 */
149 HWTEST_F(TelephonyManagerProxyTest, TestIsSimDisabledSuc, TestSize.Level1)
150 {
151 MessageParcel data;
152 OHOS::AppExecFwk::ElementName admin;
153 admin.SetBundleName(ADMIN_PACKAGENAME);
154 data.WriteParcelable(&admin);
155 data.WriteInt32(0);
156 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
157 .Times(1)
158 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
159 bool result = false;
160 int32_t ret = telephonyManagerProxy->IsSimDisabled(data, result);
161 ASSERT_TRUE(ret == ERR_OK);
162 ASSERT_FALSE(result);
163 }
164
165 /**
166 * @tc.name: TestIsSimDisabledFail
167 * @tc.desc: Test IsSimDisabled func.
168 * @tc.type: FUNC
169 */
170 HWTEST_F(TelephonyManagerProxyTest, TestIsSimDisabledFail, TestSize.Level1)
171 {
172 Utils::SetEdmServiceDisable();
173 MessageParcel data;
174 OHOS::AppExecFwk::ElementName admin;
175 admin.SetBundleName(ADMIN_PACKAGENAME);
176 data.WriteParcelable(&admin);
177 data.WriteInt32(0);
178 bool result = false;
179 int32_t ret = telephonyManagerProxy->IsSimDisabled(data, result);
180 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
181 ASSERT_FALSE(result);
182 }
183
184 /**
185 * @tc.name: TestAddCallPolicyNumbersSuc
186 * @tc.desc: Test AddCallPolicyNumbers func.
187 * @tc.type: FUNC
188 */
189 HWTEST_F(TelephonyManagerProxyTest, TestAddCallPolicyNumbersSuc, TestSize.Level1)
190 {
191 OHOS::AppExecFwk::ElementName admin;
192 admin.SetBundleName(ADMIN_PACKAGENAME);
193 std::string callType = "incoming";
194 int32_t policyFlag = 0;
195 std::vector<std::string> numbers;
196 numbers.push_back("1111111");
197 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
198 .Times(1)
199 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
200 int32_t ret = telephonyManagerProxy->AddCallPolicyNumbers(admin, callType, policyFlag, numbers);
201 ASSERT_TRUE(ret == ERR_OK);
202 }
203
204 /**
205 * @tc.name: TestAddCallPolicyNumbersFail
206 * @tc.desc: Test AddCallPolicyNumbers func.
207 * @tc.type: FUNC
208 */
209 HWTEST_F(TelephonyManagerProxyTest, TestAddCallPolicyNumbersFail, TestSize.Level1)
210 {
211 Utils::SetEdmServiceDisable();
212 OHOS::AppExecFwk::ElementName admin;
213 admin.SetBundleName(ADMIN_PACKAGENAME);
214 std::string callType = "incoming";
215 int32_t policyFlag = 0;
216 std::vector<std::string> numbers;
217 numbers.push_back("1111111");
218 int32_t ret = telephonyManagerProxy->AddCallPolicyNumbers(admin, callType, policyFlag, numbers);
219 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
220 }
221
222 /**
223 * @tc.name: TestRemoveCallPolicyNumbersSuc
224 * @tc.desc: Test RemoveCallPolicyNumbers func.
225 * @tc.type: FUNC
226 */
227 HWTEST_F(TelephonyManagerProxyTest, TestRemoveCallPolicyNumbersSuc, TestSize.Level1)
228 {
229 OHOS::AppExecFwk::ElementName admin;
230 admin.SetBundleName(ADMIN_PACKAGENAME);
231 std::string callType = "incoming";
232 int32_t policyFlag = 0;
233 std::vector<std::string> numbers;
234 numbers.push_back("1111111");
235 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
236 .Times(1)
237 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
238 int32_t ret = telephonyManagerProxy->RemoveCallPolicyNumbers(admin, callType, policyFlag, numbers);
239 ASSERT_TRUE(ret == ERR_OK);
240 }
241
242 /**
243 * @tc.name: TestRemoveCallPolicyNumbersFail
244 * @tc.desc: Test RemoveCallPolicyNumbers func.
245 * @tc.type: FUNC
246 */
247 HWTEST_F(TelephonyManagerProxyTest, TestRemoveCallPolicyNumbersFail, TestSize.Level1)
248 {
249 Utils::SetEdmServiceDisable();
250 OHOS::AppExecFwk::ElementName admin;
251 admin.SetBundleName(ADMIN_PACKAGENAME);
252 std::string callType = "incoming";
253 int32_t policyFlag = 0;
254 std::vector<std::string> numbers;
255 numbers.push_back("1111111");
256 int32_t ret = telephonyManagerProxy->RemoveCallPolicyNumbers(admin, callType, policyFlag, numbers);
257 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
258 }
259
260 /**
261 * @tc.name: TestGetCallPolicyNumbersSuc
262 * @tc.desc: Test GetCallPolicyNumbers func.
263 * @tc.type: FUNC
264 */
265 HWTEST_F(TelephonyManagerProxyTest, TestGetCallPolicyNumbersSuc, TestSize.Level1)
266 {
267 OHOS::AppExecFwk::ElementName admin;
268 admin.SetBundleName(ADMIN_PACKAGENAME);
269 std::string callType = "incoming";
270 int32_t policyFlag = 0;
271 std::vector<std::string> numbers;
272 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
273 .Times(1)
274 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
275 int32_t ret = telephonyManagerProxy->GetCallPolicyNumbers(admin, callType, policyFlag, numbers);
276 ASSERT_TRUE(ret == ERR_OK);
277 }
278
279 /**
280 * @tc.name: TestGetCallPolicyNumbersFail
281 * @tc.desc: Test GetCallPolicyNumbers func.
282 * @tc.type: FUNC
283 */
284 HWTEST_F(TelephonyManagerProxyTest, TestGetCallPolicyNumbersFail, TestSize.Level1)
285 {
286 Utils::SetEdmServiceDisable();
287 OHOS::AppExecFwk::ElementName admin;
288 admin.SetBundleName(ADMIN_PACKAGENAME);
289 std::string callType = "incoming";
290 int32_t policyFlag = 0;
291 std::vector<std::string> numbers;
292 int32_t ret = telephonyManagerProxy->GetCallPolicyNumbers(admin, callType, policyFlag, numbers);
293 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
294 }
295 } // namespace TEST
296 } // namespace EDM
297 } // namespace OHOS
298