1 /*
2 * Copyright (c) 2021 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 #include <memory>
16
17 #include "gtest/gtest.h"
18 #include "gmock/gmock.h"
19
20 #include "access_token.h"
21 #include "accesstoken_kit.h"
22 #include "dataobs_mgr_interface.h"
23 #include "datashare_errno.h"
24 #include "mock_data_ability_observer_stub.h"
25 #include "token_setproc.h"
26 #define private public
27 #include "dataobs_mgr_service.h"
28 #include "hilog_tag_wrapper.h"
29
30 namespace OHOS {
31 namespace AAFwk {
32 using namespace testing::ext;
33 static int USER_100 = 100;
34 class DataObsMgrServiceTest : public testing::Test {
35 public:
36 DataObsMgrServiceTest() = default;
37 virtual ~DataObsMgrServiceTest() = default;
38
39 static void SetUpTestCase(void);
40 static void TearDownTestCase(void);
41 void SetUp();
42 void TearDown();
43 };
SetUpTestCase(void)44 void DataObsMgrServiceTest::SetUpTestCase(void)
45 {}
TearDownTestCase(void)46 void DataObsMgrServiceTest::TearDownTestCase(void)
47 {}
SetUp()48 void DataObsMgrServiceTest::SetUp()
49 {}
TearDown()50 void DataObsMgrServiceTest::TearDown()
51 {}
52
53 /*
54 * Feature: DataObsMgrService
55 * Function: QueryServiceState
56 * SubFunction: NA
57 * FunctionPoints: DataObsMgrService QueryServiceState
58 * EnvConditions: NA
59 * CaseDescription: Verify that the DataObsMgrService could query service state.
60 */
61 HWTEST_F(DataObsMgrServiceTest, AaFwk_DataObsMgrServiceTest_QueryServiceState_0100, TestSize.Level1)
62 {
63 GTEST_LOG_(INFO) << "AaFwk_DataObsMgrServiceTest_QueryServiceState_0100 start";
64 const DataObsServiceRunningState testValue = DataObsServiceRunningState::STATE_NOT_START;
65 auto dataObsMgrServer = DelayedSingleton<DataObsMgrService>::GetInstance();
66
67 EXPECT_EQ(testValue, dataObsMgrServer->QueryServiceState());
68
69 GTEST_LOG_(INFO) << "AaFwk_DataObsMgrServiceTest_QueryServiceState_0100 end";
70 }
71
72 /*
73 * Feature: DataObsMgrService
74 * Function: RegisterObserver
75 * SubFunction: NA
76 * FunctionPoints: DataObsMgrService RegisterObserver
77 * EnvConditions: NA
78 * CaseDescription: Verify that the DataObsMgrService RegisterObserver is normal.
79 */
80 HWTEST_F(DataObsMgrServiceTest, AaFwk_DataObsMgrServiceTest_RegisterObserver_0100, TestSize.Level1)
81 {
82 GTEST_LOG_(INFO) << "AaFwk_DataObsMgrServiceTest_RegisterObserver_0100 start";
83 const int testVal = static_cast<int>(NO_ERROR);
84 const sptr<MockDataAbilityObserverStub> dataobsAbility(new (std::nothrow) MockDataAbilityObserverStub());
85 std::shared_ptr<Uri> uri =
86 std::make_shared<Uri>("dataability://device_id/com.domainname.dataability.persondata/person/10");
87 auto dataObsMgrServer = DelayedSingleton<DataObsMgrService>::GetInstance();
88
89 EXPECT_EQ(testVal, dataObsMgrServer->RegisterObserver(*uri, dataobsAbility));
90
91 testing::Mock::AllowLeak(dataobsAbility);
92 GTEST_LOG_(INFO) << "AaFwk_DataObsMgrServiceTest_RegisterObserver_0100 end";
93 }
94
95 /*
96 * Feature: DataObsMgrService
97 * Function: RegisterObserver
98 * SubFunction: NA
99 * FunctionPoints: DataObsMgrService RegisterObserver
100 * EnvConditions: NA
101 * CaseDescription: Verify that the DataObsMgrService RegisterObserver is abnormal.
102 */
103 HWTEST_F(DataObsMgrServiceTest, AaFwk_DataObsMgrServiceTest_RegisterObserver_0200, TestSize.Level1)
104 {
105 GTEST_LOG_(INFO) << "AaFwk_DataObsMgrServiceTest_RegisterObserver_0200 start";
106 const int testVal = static_cast<int>(DATA_OBSERVER_IS_NULL);
107 std::shared_ptr<Uri> uri =
108 std::make_shared<Uri>("dataability://device_id/com.domainname.dataability.persondata/person/10");
109 auto dataObsMgrServer = DelayedSingleton<DataObsMgrService>::GetInstance();
110
111 EXPECT_EQ(testVal, dataObsMgrServer->RegisterObserver(*uri, nullptr));
112
113 GTEST_LOG_(INFO) << "AaFwk_DataObsMgrServiceTest_RegisterObserver_0200 end";
114 }
115
116 /*
117 * Feature: DataObsMgrService
118 * Function: RegisterObserver
119 * SubFunction: NA
120 * FunctionPoints: DataObsMgrService RegisterObserver
121 * EnvConditions: NA
122 * CaseDescription: Verify that the DataObsMgrService RegisterObserver is abnormal.
123 */
124 HWTEST_F(DataObsMgrServiceTest, AaFwk_DataObsMgrServiceTest_RegisterObserver_0300, TestSize.Level1)
125 {
126 GTEST_LOG_(INFO) << "AaFwk_DataObsMgrServiceTest_RegisterObserver_0300 start";
127 const int testVal = static_cast<int>(DATAOBS_SERVICE_INNER_IS_NULL);
128 const sptr<MockDataAbilityObserverStub> dataobsAbility(new (std::nothrow) MockDataAbilityObserverStub());
129 std::shared_ptr<Uri> uri =
130 std::make_shared<Uri>("dataability://device_id/com.domainname.dataability.persondata/person/10");
131 auto dataObsMgrServer = DelayedSingleton<DataObsMgrService>::GetInstance();
132
133 dataObsMgrServer->dataObsMgrInner_.reset();
134 EXPECT_EQ(testVal, dataObsMgrServer->RegisterObserver(*uri, dataobsAbility));
135 dataObsMgrServer->dataObsMgrInner_ = std::make_shared<DataObsMgrInner>();
136
137 testing::Mock::AllowLeak(dataobsAbility);
138 GTEST_LOG_(INFO) << "AaFwk_DataObsMgrServiceTest_RegisterObserver_0300 end";
139 }
140
141 /*
142 * Feature: DataObsMgrService
143 * Function: RegisterObserver
144 * SubFunction: NA
145 * FunctionPoints: DataObsMgrService RegisterObserver
146 * EnvConditions: NA
147 * CaseDescription: Verify that the DataObsMgrService RegisterObserver is abnormal.
148 */
149 HWTEST_F(DataObsMgrServiceTest, AaFwk_DataObsMgrServiceTest_RegisterObserver_0400, TestSize.Level1)
150 {
151 GTEST_LOG_(INFO) << "AaFwk_DataObsMgrServiceTest_RegisterObserver_0300 start";
152 const int testVal = static_cast<int>(DATAOBS_INVALID_USERID);
153 const sptr<MockDataAbilityObserverStub> dataobsAbility(new (std::nothrow) MockDataAbilityObserverStub());
154 auto originalToken = GetSelfTokenID();
155
156 SetSelfTokenID(0);
157 std::shared_ptr<Uri> uri =
158 std::make_shared<Uri>("dataability://device_id/com.domainname.dataability.persondata/person/10");
159 auto dataObsMgrServer = std::make_shared<DataObsMgrService>();
160
161 EXPECT_EQ(testVal, dataObsMgrServer->RegisterObserver(*uri, dataobsAbility));
162 dataObsMgrServer->dataObsMgrInner_ = std::make_shared<DataObsMgrInner>();
163 testing::Mock::AllowLeak(dataobsAbility);
164 int count = 0;
__anonac937fd00102() 165 ON_CALL(*dataobsAbility, OnChange()).WillByDefault(testing::Invoke([&count]() {
166 count++;
167 }));
168 dataObsMgrServer->NotifyChange(*uri);
169 EXPECT_EQ(count, 0);
170
171 SetSelfTokenID(originalToken);
172 GTEST_LOG_(INFO) << "AaFwk_DataObsMgrServiceTest_RegisterObserver_0300 end";
173 }
174
175 /*
176 * Feature: DataObsMgrService
177 * Function: UnregisterObserver
178 * SubFunction: NA
179 * FunctionPoints: DataObsMgrService UnregisterObserver
180 * EnvConditions: NA
181 * CaseDescription: Verify that the DataObsMgrService UnregisterObserver is normal.
182 */
183 HWTEST_F(DataObsMgrServiceTest, AaFwk_DataObsMgrServiceTest_UnregisterObserver_0100, TestSize.Level1)
184 {
185 GTEST_LOG_(INFO) << "AaFwk_DataObsMgrServiceTest_UnregisterObserver_0100 start";
186 const int testVal = static_cast<int>(NO_ERROR);
187 const sptr<MockDataAbilityObserverStub> dataobsAbility(new (std::nothrow) MockDataAbilityObserverStub());
188 std::shared_ptr<Uri> uri =
189 std::make_shared<Uri>("dataability://device_id/com.domainname.dataability.persondata/person/10");
190 auto dataObsMgrServer = DelayedSingleton<DataObsMgrService>::GetInstance();
191
192 EXPECT_EQ(testVal, dataObsMgrServer->RegisterObserver(*uri, dataobsAbility));
193 EXPECT_EQ(testVal, dataObsMgrServer->UnregisterObserver(*uri, dataobsAbility));
194
195 GTEST_LOG_(INFO) << "AaFwk_DataObsMgrServiceTest_UnregisterObserver_0100 end";
196 }
197
198 /*
199 * Feature: DataObsMgrService
200 * Function: UnregisterObserver
201 * SubFunction: NA
202 * FunctionPoints: DataObsMgrService UnregisterObserver
203 * EnvConditions: NA
204 * CaseDescription: Verify that the DataObsMgrService UnregisterObserver is abnormal.
205 */
206 HWTEST_F(DataObsMgrServiceTest, AaFwk_DataObsMgrServiceTest_UnregisterObserver_0200, TestSize.Level1)
207 {
208 GTEST_LOG_(INFO) << "AaFwk_DataObsMgrServiceTest_UnregisterObserver_0200 start";
209 const int testVal = static_cast<int>(DATA_OBSERVER_IS_NULL);
210 std::shared_ptr<Uri> uri =
211 std::make_shared<Uri>("dataability://device_id/com.domainname.dataability.persondata/person/10");
212 auto dataObsMgrServer = DelayedSingleton<DataObsMgrService>::GetInstance();
213
214 EXPECT_EQ(testVal, dataObsMgrServer->UnregisterObserver(*uri, nullptr));
215
216 GTEST_LOG_(INFO) << "AaFwk_DataObsMgrServiceTest_UnregisterObserver_0200 end";
217 }
218
219 /*
220 * Feature: DataObsMgrService
221 * Function: UnregisterObserver
222 * SubFunction: NA
223 * FunctionPoints: DataObsMgrService UnregisterObserver
224 * EnvConditions: NA
225 * CaseDescription: Verify that the DataObsMgrService UnregisterObserver is abnormal.
226 */
227 HWTEST_F(DataObsMgrServiceTest, AaFwk_DataObsMgrServiceTest_UnregisterObserver_0300, TestSize.Level1)
228 {
229 GTEST_LOG_(INFO) << "AaFwk_DataObsMgrServiceTest_UnregisterObserver_0300 start";
230 const int testVal = static_cast<int>(DATAOBS_SERVICE_INNER_IS_NULL);
231 const sptr<MockDataAbilityObserverStub> dataobsAbility(new (std::nothrow) MockDataAbilityObserverStub());
232 std::shared_ptr<Uri> uri =
233 std::make_shared<Uri>("dataability://device_id/com.domainname.dataability.persondata/person/10");
234 auto dataObsMgrServer = DelayedSingleton<DataObsMgrService>::GetInstance();
235
236 dataObsMgrServer->dataObsMgrInner_.reset();
237 EXPECT_EQ(testVal, dataObsMgrServer->UnregisterObserver(*uri, dataobsAbility));
238 dataObsMgrServer->dataObsMgrInner_ = std::make_shared<DataObsMgrInner>();
239
240 GTEST_LOG_(INFO) << "AaFwk_DataObsMgrServiceTest_UnregisterObserver_0300 end";
241 }
242
243 /*
244 * Feature: DataObsMgrService
245 * Function: NotifyChange
246 * SubFunction: NA
247 * FunctionPoints: DataObsMgrService NotifyChange
248 * EnvConditions: NA
249 * CaseDescription: Verify that the DataObsMgrService NotifyChange is normal.
250 */
251 HWTEST_F(DataObsMgrServiceTest, AaFwk_DataObsMgrServiceTest_NotifyChange_0100, TestSize.Level1)
252 {
253 GTEST_LOG_(INFO) << "AaFwk_DataObsMgrServiceTest_NotifyChange_0100 start";
254 const int testVal = static_cast<int>(DATAOBS_SERVICE_HANDLER_IS_NULL);
255 std::shared_ptr<Uri> uri =
256 std::make_shared<Uri>("dataability://device_id/com.domainname.dataability.persondata/person/10");
257 auto dataObsMgrServer = DelayedSingleton<DataObsMgrService>::GetInstance();
258
259 EXPECT_EQ(testVal, dataObsMgrServer->NotifyChange(*uri));
260
261 GTEST_LOG_(INFO) << "AaFwk_DataObsMgrServiceTest_NotifyChange_0100 end";
262 }
263
264 /*
265 * Feature: DataObsMgrService
266 * Function: NotifyChange
267 * SubFunction: NA
268 * FunctionPoints: DataObsMgrService NotifyChange
269 * EnvConditions: NA
270 * CaseDescription: Verify that the DataObsMgrService NotifyChange is abnormal.
271 */
272 HWTEST_F(DataObsMgrServiceTest, AaFwk_DataObsMgrServiceTest_NotifyChange_0200, TestSize.Level1)
273 {
274 GTEST_LOG_(INFO) << "AaFwk_DataObsMgrServiceTest_NotifyChange_0200 start";
275 const int testVal = static_cast<int>(DATAOBS_SERVICE_HANDLER_IS_NULL);
276 std::shared_ptr<Uri> uri =
277 std::make_shared<Uri>("dataability://device_id/com.domainname.dataability.persondata/person/10");
278 auto dataObsMgrServer = DelayedSingleton<DataObsMgrService>::GetInstance();
279
280 dataObsMgrServer->OnStop();
281 EXPECT_EQ(testVal, dataObsMgrServer->NotifyChange(*uri));
282
283 GTEST_LOG_(INFO) << "AaFwk_DataObsMgrServiceTest_NotifyChange_0200 end";
284 }
285
286 /*
287 * Feature: DataObsMgrService
288 * Function: NotifyChange
289 * SubFunction: NA
290 * FunctionPoints: DataObsMgrService NotifyChange
291 * EnvConditions: NA
292 * CaseDescription: Verify that the DataObsMgrService NotifyChange is abnormal.
293 */
294 HWTEST_F(DataObsMgrServiceTest, AaFwk_DataObsMgrServiceTest_NotifyChange_0300, TestSize.Level1)
295 {
296 GTEST_LOG_(INFO) << "AaFwk_DataObsMgrServiceTest_NotifyChange_0300 start";
297 const int testVal = static_cast<int>(DATAOBS_SERVICE_HANDLER_IS_NULL);
298 std::shared_ptr<Uri> uri =
299 std::make_shared<Uri>("dataability://device_id/com.domainname.dataability.persondata/person/10");
300 auto dataObsMgrServer = DelayedSingleton<DataObsMgrService>::GetInstance();
301
302 dataObsMgrServer->dataObsMgrInner_.reset();
303 EXPECT_EQ(testVal, dataObsMgrServer->NotifyChange(*uri));
304 dataObsMgrServer->dataObsMgrInner_ = std::make_shared<DataObsMgrInner>();
305
306 GTEST_LOG_(INFO) << "AaFwk_DataObsMgrServiceTest_NotifyChange_0300 end";
307 }
308
309 /*
310 * Feature: DataObsMgrService
311 * Function: NotifyChange
312 * SubFunction: NA
313 * FunctionPoints: DataObsMgrService NotifyChange
314 * EnvConditions: NA
315 * CaseDescription: Verify that the DataObsMgrService NotifyChange is abnormal.
316 */
317 HWTEST_F(DataObsMgrServiceTest, AaFwk_DataObsMgrServiceTest_NotifyChange_0400, TestSize.Level1)
318 {
319 GTEST_LOG_(INFO) << "AaFwk_DataObsMgrServiceTest_NotifyChange_0400 start";
320 const int testVal = static_cast<int>(DATAOBS_SERVICE_HANDLER_IS_NULL);
321 std::shared_ptr<Uri> uri =
322 std::make_shared<Uri>("dataability://device_id/com.domainname.dataability.persondata/person/10");
323 auto dataObsMgrServer = DelayedSingleton<DataObsMgrService>::GetInstance();
324
325 dataObsMgrServer->taskCount_ = 50;
326 EXPECT_EQ(testVal, dataObsMgrServer->NotifyChange(*uri));
327 dataObsMgrServer->taskCount_ = 0;
328
329 GTEST_LOG_(INFO) << "AaFwk_DataObsMgrServiceTest_NotifyChange_0400 end";
330 }
331
332 /*
333 * Feature: DataObsMgrService
334 * Function: RegisterObserverExt
335 * SubFunction: NA
336 * FunctionPoints: DataObsMgrService RegisterObserverExt
337 * EnvConditions: NA
338 * CaseDescription: Verify that the DataObsMgrService RegisterObserver is normal.
339 */
340 HWTEST_F(DataObsMgrServiceTest, DataObsMgrServiceTest_RegisterObserverExt_0100, TestSize.Level1)
341 {
342 GTEST_LOG_(INFO) << "DataObsMgrServiceTest_RegisterObserverExt_0100 start";
343 const int testVal = static_cast<int>(NO_ERROR);
344 const sptr<MockDataAbilityObserverStub> dataobsAbility(new (std::nothrow) MockDataAbilityObserverStub());
345 Uri uri("dataobs://authority/com.domainname.dataability.persondata/ person/10");
346 auto dataObsMgrServer = DelayedSingleton<DataObsMgrService>::GetInstance();
347
348 EXPECT_EQ(testVal, dataObsMgrServer->RegisterObserverExt(uri, dataobsAbility, false));
349 EXPECT_EQ(testVal, dataObsMgrServer->RegisterObserverExt(uri, dataobsAbility, true));
350
351 GTEST_LOG_(INFO) << "DataObsMgrServiceTest_RegisterObserverExt_0100 end";
352 }
353
354 /*
355 * Feature: DataObsMgrService
356 * Function: RegisterObserverExt
357 * SubFunction: NA
358 * FunctionPoints: DataObsMgrService RegisterObserverExt
359 * EnvConditions: NA
360 * CaseDescription: Verify that the DataObsMgrService RegisterObserver is abnormal.
361 */
362 HWTEST_F(DataObsMgrServiceTest, DataObsMgrServiceTest_RegisterObserverExt_0200, TestSize.Level1)
363 {
364 GTEST_LOG_(INFO) << "DataObsMgrServiceTest_RegisterObserverExt_0200 start";
365 const int testVal = static_cast<int>(DATA_OBSERVER_IS_NULL);
366 Uri uri("dataobs://authority/com.domainname.dataability.persondata/ person/10");
367 auto dataObsMgrServer = DelayedSingleton<DataObsMgrService>::GetInstance();
368
369 EXPECT_EQ(testVal, dataObsMgrServer->RegisterObserverExt(uri, nullptr, true));
370
371 GTEST_LOG_(INFO) << "DataObsMgrServiceTest_RegisterObserverExt_0200 end";
372 }
373
374 /*
375 * Feature: DataObsMgrService
376 * Function: RegisterObserverExt
377 * SubFunction: NA
378 * FunctionPoints: DataObsMgrService RegisterObserverExt
379 * EnvConditions: NA
380 * CaseDescription: Verify that the DataObsMgrService RegisterObserver is abnormal.
381 */
382 HWTEST_F(DataObsMgrServiceTest, DataObsMgrServiceTest_RegisterObserverExt_0300, TestSize.Level1)
383 {
384 GTEST_LOG_(INFO) << "DataObsMgrServiceTest_RegisterObserverExt_0300 start";
385 const int testVal = static_cast<int>(DATAOBS_SERVICE_INNER_IS_NULL);
386 const sptr<MockDataAbilityObserverStub> dataobsAbility(new (std::nothrow) MockDataAbilityObserverStub());
387 Uri uri("dataobs://authority/com.domainname.dataability.persondata/ person/10");
388 auto dataObsMgrServer = DelayedSingleton<DataObsMgrService>::GetInstance();
389
390 dataObsMgrServer->dataObsMgrInnerExt_.reset();
391 EXPECT_EQ(testVal, dataObsMgrServer->RegisterObserverExt(uri, dataobsAbility, true));
392 dataObsMgrServer->dataObsMgrInnerExt_ = std::make_shared<DataObsMgrInnerExt>();
393
394 GTEST_LOG_(INFO) << "DataObsMgrServiceTest_RegisterObserverExt_0300 end";
395 }
396
397 /*
398 * Feature: DataObsMgrService
399 * Function: UnregisterObserverExt
400 * SubFunction: NA
401 * FunctionPoints: DataObsMgrService UnregisterObserverExt
402 * EnvConditions: NA
403 * CaseDescription: Verify that the DataObsMgrService UnregisterObserverExt is normal.
404 */
405 HWTEST_F(DataObsMgrServiceTest, DataObsMgrServiceTest_UnregisterObserverExt_0100, TestSize.Level1)
406 {
407 GTEST_LOG_(INFO) << "DataObsMgrServiceTest_UnregisterObserverExt_0100 start";
408 const int testVal = static_cast<int>(NO_ERROR);
409 const sptr<MockDataAbilityObserverStub> dataobsAbility(new (std::nothrow) MockDataAbilityObserverStub());
410 Uri uri("dataobs://authority/com.domainname.dataability.persondata/ person/10");
411 auto dataObsMgrServer = DelayedSingleton<DataObsMgrService>::GetInstance();
412
413 EXPECT_EQ(testVal, dataObsMgrServer->RegisterObserverExt(uri, dataobsAbility, true));
414 EXPECT_EQ(testVal, dataObsMgrServer->UnregisterObserverExt(uri, dataobsAbility));
415
416 GTEST_LOG_(INFO) << "DataObsMgrServiceTest_UnregisterObserverExt_0100 end";
417 }
418
419 /*
420 * Feature: DataObsMgrService
421 * Function: UnregisterObserverExt
422 * SubFunction: NA
423 * FunctionPoints: DataObsMgrService UnregisterObserverExt
424 * EnvConditions: NA
425 * CaseDescription: Verify that the DataObsMgrService UnregisterObserverExt is normal.
426 */
427 HWTEST_F(DataObsMgrServiceTest, DataObsMgrServiceTest_UnregisterObserverExt_0200, TestSize.Level1)
428 {
429 GTEST_LOG_(INFO) << "DataObsMgrServiceTest_UnregisterObserverExt_0200 start";
430 const int testVal = static_cast<int>(NO_ERROR);
431 const sptr<MockDataAbilityObserverStub> dataobsAbility(new (std::nothrow) MockDataAbilityObserverStub());
432 Uri uri("dataobs://authority/com.domainname.dataability.persondata/ person/10");
433 auto dataObsMgrServer = DelayedSingleton<DataObsMgrService>::GetInstance();
434
435 EXPECT_EQ(testVal, dataObsMgrServer->RegisterObserverExt(uri, dataobsAbility, true));
436 EXPECT_EQ(testVal, dataObsMgrServer->UnregisterObserverExt(dataobsAbility));
437
438 GTEST_LOG_(INFO) << "DataObsMgrServiceTest_UnregisterObserverExt_0200 end";
439 }
440
441 /*
442 * Feature: DataObsMgrService
443 * Function: UnregisterObserverExt
444 * SubFunction: NA
445 * FunctionPoints: DataObsMgrService UnregisterObserverExt
446 * EnvConditions: NA
447 * CaseDescription: Verify that the DataObsMgrService UnregisterObserverExt is abnormal.
448 */
449 HWTEST_F(DataObsMgrServiceTest, DataObsMgrServiceTest_UnregisterObserverExt_0300, TestSize.Level1)
450 {
451 GTEST_LOG_(INFO) << "DataObsMgrServiceTest_UnregisterObserverExt_0300 start";
452 const int testVal = static_cast<int>(DATA_OBSERVER_IS_NULL);
453 Uri uri("dataobs://authority/com.domainname.dataability.persondata/ person/10");
454 auto dataObsMgrServer = DelayedSingleton<DataObsMgrService>::GetInstance();
455
456 EXPECT_EQ(testVal, dataObsMgrServer->UnregisterObserverExt(uri, nullptr));
457
458 GTEST_LOG_(INFO) << "DataObsMgrServiceTest_UnregisterObserverExt_0300 end";
459 }
460
461 /*
462 * Feature: DataObsMgrService
463 * Function: UnregisterObserverExt
464 * SubFunction: NA
465 * FunctionPoints: DataObsMgrService UnregisterObserverExt
466 * EnvConditions: NA
467 * CaseDescription: Verify that the DataObsMgrService UnregisterObserverExt is abnormal.
468 */
469 HWTEST_F(DataObsMgrServiceTest, DataObsMgrServiceTest_UnregisterObserverExt_0400, TestSize.Level1)
470 {
471 GTEST_LOG_(INFO) << "DataObsMgrServiceTest_UnregisterObserverExt_0400 start";
472 const int testVal = static_cast<int>(DATAOBS_SERVICE_INNER_IS_NULL);
473 const sptr<MockDataAbilityObserverStub> dataobsAbility(new (std::nothrow) MockDataAbilityObserverStub());
474 Uri uri("dataobs://authority/com.domainname.dataability.persondata/ person/10");
475 auto dataObsMgrServer = DelayedSingleton<DataObsMgrService>::GetInstance();
476
477 dataObsMgrServer->dataObsMgrInnerExt_.reset();
478 EXPECT_EQ(testVal, dataObsMgrServer->UnregisterObserverExt(uri, dataobsAbility));
479 dataObsMgrServer->dataObsMgrInnerExt_ = std::make_shared<DataObsMgrInnerExt>();
480
481 GTEST_LOG_(INFO) << "DataObsMgrServiceTest_UnregisterObserverExt_0400 end";
482 }
483
484 /*
485 * Feature: DataObsMgrService
486 * Function: UnregisterObserverExt
487 * SubFunction: NA
488 * FunctionPoints: DataObsMgrService UnregisterObserverExt
489 * EnvConditions: NA
490 * CaseDescription: Verify that the DataObsMgrService UnregisterObserverExt is abnormal.
491 */
492 HWTEST_F(DataObsMgrServiceTest, DataObsMgrServiceTest_UnregisterObserverExt_0500, TestSize.Level1)
493 {
494 GTEST_LOG_(INFO) << "DataObsMgrServiceTest_UnregisterObserverExt_0500 start";
495 const int testVal = static_cast<int>(DATA_OBSERVER_IS_NULL);
496 Uri uri("dataobs://authority/com.domainname.dataability.persondata/ person/10");
497 auto dataObsMgrServer = DelayedSingleton<DataObsMgrService>::GetInstance();
498
499 EXPECT_EQ(testVal, dataObsMgrServer->UnregisterObserverExt(nullptr));
500
501 GTEST_LOG_(INFO) << "DataObsMgrServiceTest_UnregisterObserverExt_0500 end";
502 }
503
504 /*
505 * Feature: DataObsMgrService
506 * Function: UnregisterObserverExt
507 * SubFunction: NA
508 * FunctionPoints: DataObsMgrService UnregisterObserverExt
509 * EnvConditions: NA
510 * CaseDescription: Verify that the DataObsMgrService UnregisterObserverExt is abnormal.
511 */
512 HWTEST_F(DataObsMgrServiceTest, DataObsMgrServiceTest_UnregisterObserverExt_0600, TestSize.Level1)
513 {
514 GTEST_LOG_(INFO) << "DataObsMgrServiceTest_UnregisterObserverExt_0600 start";
515 const int testVal = static_cast<int>(DATAOBS_SERVICE_INNER_IS_NULL);
516 const sptr<MockDataAbilityObserverStub> dataobsAbility(new (std::nothrow) MockDataAbilityObserverStub());
517 Uri uri("dataobs://authority/com.domainname.dataability.persondata/ person/10");
518 auto dataObsMgrServer = DelayedSingleton<DataObsMgrService>::GetInstance();
519
520 dataObsMgrServer->dataObsMgrInnerExt_.reset();
521 EXPECT_EQ(testVal, dataObsMgrServer->UnregisterObserverExt(dataobsAbility));
522 dataObsMgrServer->dataObsMgrInnerExt_ = std::make_shared<DataObsMgrInnerExt>();
523
524 GTEST_LOG_(INFO) << "DataObsMgrServiceTest_UnregisterObserverExt_0600 end";
525 }
526
527 /*
528 * Feature: DataObsMgrService
529 * Function: NotifyChangeExt
530 * SubFunction: NA
531 * FunctionPoints: DataObsMgrService NotifyChangeExt
532 * EnvConditions: NA
533 * CaseDescription: Verify that the DataObsMgrService NotifyChangeExt is normal.
534 */
535 HWTEST_F(DataObsMgrServiceTest, DataObsMgrServiceTest_NotifyChangeExt_0100, TestSize.Level1)
536 {
537 GTEST_LOG_(INFO) << "DataObsMgrServiceTest_NotifyChangeExt_0100 start";
538 const int testVal = static_cast<int>(DATAOBS_SERVICE_HANDLER_IS_NULL);
539 Uri uri("dataobs://authority/com.domainname.dataability.persondata/ person/10");
540 auto dataObsMgrServer = DelayedSingleton<DataObsMgrService>::GetInstance();
541
542 EXPECT_EQ(testVal, dataObsMgrServer->NotifyChangeExt({ ChangeInfo::ChangeType::UPDATE, { uri } }));
543 GTEST_LOG_(INFO) << "DataObsMgrServiceTest_NotifyChangeExt_0100 end";
544 }
545
546 /*
547 * Feature: DataObsMgrService
548 * Function: NotifyChangeExt
549 * SubFunction: NA
550 * FunctionPoints: DataObsMgrService NotifyChangeExt
551 * EnvConditions: NA
552 * CaseDescription: Verify that the DataObsMgrService NotifyChangeExt is abnormal.
553 */
554 HWTEST_F(DataObsMgrServiceTest, DataObsMgrServiceTest_NotifyChangeExt_0200, TestSize.Level1)
555 {
556 GTEST_LOG_(INFO) << "DataObsMgrServiceTest_NotifyChangeExt_0200 start";
557 const int testVal = static_cast<int>(DATAOBS_SERVICE_HANDLER_IS_NULL);
558 Uri uri("dataobs://authority/com.domainname.dataability.persondata/ person/10");
559 auto dataObsMgrServer = DelayedSingleton<DataObsMgrService>::GetInstance();
560
561 dataObsMgrServer->OnStop();
562 EXPECT_EQ(testVal, dataObsMgrServer->NotifyChangeExt({ ChangeInfo::ChangeType::UPDATE, { uri } }));
563 GTEST_LOG_(INFO) << "DataObsMgrServiceTest_NotifyChangeExt_0200 end";
564 }
565
566 /*
567 * Feature: DataObsMgrService
568 * Function: NotifyChangeExt
569 * SubFunction: NA
570 * FunctionPoints: DataObsMgrService NotifyChangeExt
571 * EnvConditions: NA
572 * CaseDescription: Verify that the DataObsMgrService NotifyChangeExt is abnormal.
573 */
574 HWTEST_F(DataObsMgrServiceTest, DataObsMgrServiceTest_NotifyChangeExt_0300, TestSize.Level1)
575 {
576 GTEST_LOG_(INFO) << "DataObsMgrServiceTest_NotifyChangeExt_0300 start";
577 const int testVal = static_cast<int>(DATAOBS_SERVICE_HANDLER_IS_NULL);
578 Uri uri("dataobs://authority/com.domainname.dataability.persondata/ person/10");
579 auto dataObsMgrServer = DelayedSingleton<DataObsMgrService>::GetInstance();
580
581 dataObsMgrServer->dataObsMgrInner_.reset();
582 EXPECT_EQ(testVal, dataObsMgrServer->NotifyChangeExt({ ChangeInfo::ChangeType::UPDATE, { uri } }));
583 dataObsMgrServer->dataObsMgrInner_ = std::make_shared<DataObsMgrInner>();
584 GTEST_LOG_(INFO) << "DataObsMgrServiceTest_NotifyChangeExt_0300 end";
585 }
586
587 /*
588 * Feature: DataObsMgrService
589 * Function: OnStop
590 * SubFunction: NA
591 * FunctionPoints: DataObsMgrService OnStop
592 * EnvConditions: NA
593 * CaseDescription: Verify that the DataObsMgrService OnStop is normal.
594 */
595 HWTEST_F(DataObsMgrServiceTest, AaFwk_DataObsMgrServiceTest_OnStop_0100, TestSize.Level1)
596 {
597 GTEST_LOG_(INFO) << "AaFwk_DataObsMgrServiceTest_OnStop_0100 start";
598 const DataObsServiceRunningState testValue = DataObsServiceRunningState::STATE_NOT_START;
599 auto dataObsMgrServer = DelayedSingleton<DataObsMgrService>::GetInstance();
600
601 dataObsMgrServer->OnStop();
602 EXPECT_EQ(testValue, dataObsMgrServer->QueryServiceState());
603
604 GTEST_LOG_(INFO) << "AaFwk_DataObsMgrServiceTest_OnStop_0100 end";
605 }
606
607 /*
608 * Feature: DataObsMgrService
609 * Function: Dump
610 * SubFunction: NA
611 * FunctionPoints: DataObsMgrService Dump
612 * EnvConditions: NA
613 * CaseDescription: Verify that the DataObsMgrService Dump is normal.
614 */
615 HWTEST_F(DataObsMgrServiceTest, AaFwk_DataObsMgrServiceTest_Dump_0100, TestSize.Level1)
616 {
617 GTEST_LOG_(INFO) << "AaFwk_DataObsMgrServiceTest_Dump_0100 start";
618 const DataObsServiceRunningState testValue = DataObsServiceRunningState::STATE_RUNNING;
619 auto dataObsMgrServer = DelayedSingleton<DataObsMgrService>::GetInstance();
620
621 std::string fileName = "test.txt";
622 std::vector<std::u16string> args;
623 args.push_back(u"-h");
624 FILE *fp = fopen(fileName.c_str(), "w");
625 int ret = dataObsMgrServer->Dump(fileno(fp), args);
626 fclose(fp);
627 EXPECT_EQ(SUCCESS, ret);
628
629 GTEST_LOG_(INFO) << "AaFwk_DataObsMgrServiceTest_Dump_0100 end";
630 }
631
632 /*
633 * Feature: DataObsMgrService
634 * Function: CheckSystemCallingPermission
635 * SubFunction: NA
636 * FunctionPoints: DataObsMgrService CheckSystemCallingPermission
637 * EnvConditions: NA
638 * CaseDescription: Verify that the DataObsMgrService CheckSystemCallingPermission is normal.
639 */
640 HWTEST_F(DataObsMgrServiceTest, AaFwk_DataObsMgrServiceTest_CheckSystemCallingPermission_0100, TestSize.Level1)
641 {
642 TAG_LOGI(AAFwkTag::DBOBSMGR, "AaFwk_DataObsMgrServiceTest_CheckSystemCallingPermission_0100 start");
643 auto dataObsMgrServer = std::make_shared<DataObsMgrService>();
644 auto originalToken = GetSelfTokenID();
645
646 // set system app
647 uint64_t systemAppMask = (static_cast<uint64_t>(1) << 32);
648 uint32_t tokenID = Security::AccessToken::DEFAULT_TOKEN_VERSION;
649 Security::AccessToken::AccessTokenIDInner *idInner =
650 reinterpret_cast<Security::AccessToken::AccessTokenIDInner *>(&tokenID);
651 idInner->type = Security::AccessToken::TOKEN_HAP;
652 uint64_t fullTokenId = systemAppMask | tokenID;
653 SetSelfTokenID(fullTokenId);
654 DataObsOption opt;
655 bool ret = 0;
656 opt.isSystem = true;
657 ret = dataObsMgrServer->IsCallingPermissionValid(opt, IDataObsMgr::DATAOBS_DEFAULT_CURRENT_USER, -1);
658 EXPECT_EQ(ret, false);
659 ret = dataObsMgrServer->IsCallingPermissionValid(opt, IDataObsMgr::DATAOBS_DEFAULT_CURRENT_USER, 100);
660 EXPECT_EQ(ret, true);
661 ret = dataObsMgrServer->IsCallingPermissionValid(opt, 100, 101);
662 EXPECT_EQ(ret, true);
663 ret = dataObsMgrServer->IsCallingPermissionValid(opt);
664 EXPECT_EQ(ret, true);
665
666 opt.isSystem = false;
667 ret = dataObsMgrServer->IsCallingPermissionValid(opt, IDataObsMgr::DATAOBS_DEFAULT_CURRENT_USER, -1);
668 EXPECT_EQ(ret, false);
669 ret = dataObsMgrServer->IsCallingPermissionValid(opt, IDataObsMgr::DATAOBS_DEFAULT_CURRENT_USER, 100);
670 EXPECT_EQ(ret, true);
671 ret = dataObsMgrServer->IsCallingPermissionValid(opt, 100, 101);
672 EXPECT_EQ(ret, true);
673 ret = dataObsMgrServer->IsCallingPermissionValid(opt);
674 EXPECT_EQ(ret, true);
675
676 SetSelfTokenID(originalToken);
677 TAG_LOGI(AAFwkTag::DBOBSMGR, "AaFwk_DataObsMgrServiceTest_CheckSystemCallingPermission_0100 end");
678 }
679
680 /*
681 * Feature: DataObsMgrService
682 * Function: CheckSystemCallingPermission
683 * SubFunction: NA
684 * FunctionPoints: DataObsMgrService CheckSystemCallingPermission
685 * EnvConditions: NA
686 * CaseDescription: Verify that the DataObsMgrService CheckSystemCallingPermission is normal.
687 */
688 HWTEST_F(DataObsMgrServiceTest, AaFwk_DataObsMgrServiceTest_CheckSystemCallingPermission_0200, TestSize.Level1)
689 {
690 TAG_LOGI(AAFwkTag::DBOBSMGR, "AaFwk_DataObsMgrServiceTest_CheckSystemCallingPermission_0200 start");
691 auto dataObsMgrServer = std::make_shared<DataObsMgrService>();
692 auto originalToken = GetSelfTokenID();
693
694 // set token native
695 uint32_t tokenID = Security::AccessToken::DEFAULT_TOKEN_VERSION;
696 Security::AccessToken::AccessTokenIDInner *idInner =
697 reinterpret_cast<Security::AccessToken::AccessTokenIDInner *>(&tokenID);
698 idInner->type = Security::AccessToken::TOKEN_NATIVE;
699 SetSelfTokenID(tokenID);
700
701 DataObsOption opt;
702 bool ret = 0;
703 opt.isSystem = false;
704 ret = dataObsMgrServer->IsCallingPermissionValid(opt, IDataObsMgr::DATAOBS_DEFAULT_CURRENT_USER, -1);
705 EXPECT_EQ(ret, false);
706 ret = dataObsMgrServer->IsCallingPermissionValid(opt, IDataObsMgr::DATAOBS_DEFAULT_CURRENT_USER, 100);
707 EXPECT_EQ(ret, true);
708 ret = dataObsMgrServer->IsCallingPermissionValid(opt, 100, 101);
709 EXPECT_EQ(ret, false);
710 opt.isSystem = true;
711 ret = dataObsMgrServer->IsCallingPermissionValid(opt, IDataObsMgr::DATAOBS_DEFAULT_CURRENT_USER, 100);
712 EXPECT_EQ(ret, false);
713
714 SetSelfTokenID(originalToken);
715 TAG_LOGI(AAFwkTag::DBOBSMGR, "AaFwk_DataObsMgrServiceTest_CheckSystemCallingPermission_0200 end");
716 }
717
718 /*
719 * Feature: DataObsMgrService
720 * Function: GetDataMgrServiceUid
721 * SubFunction: NA
722 * FunctionPoints: DataObsMgrService GetDataMgrServiceUid
723 * EnvConditions: NA
724 * CaseDescription: Verify that the DataObsMgrService GetDataMgrServiceUid is normal.
725 */
726 HWTEST_F(DataObsMgrServiceTest, AaFwk_DataObsMgrServiceTest_GetDataMgrServiceUid_0100, TestSize.Level1)
727 {
728 TAG_LOGI(AAFwkTag::DBOBSMGR, "AaFwk_DataObsMgrServiceTest_GetDataMgrServiceUid_0100 start");
729 auto dataObsMgrServer = std::make_shared<DataObsMgrService>();
730
731 auto uid1 = dataObsMgrServer->GetDataMgrServiceUid();
732 EXPECT_NE(uid1, 0);
733 auto uid2 = dataObsMgrServer->GetDataMgrServiceUid();
734 EXPECT_EQ(uid1, uid2);
735
736 uint32_t tokenID = Security::AccessToken::DEFAULT_TOKEN_VERSION;
737 Security::AccessToken::AccessTokenIDInner *idInner =
738 reinterpret_cast<Security::AccessToken::AccessTokenIDInner *>(&tokenID);
739 idInner->type = Security::AccessToken::TOKEN_NATIVE;
740 bool ret = dataObsMgrServer->IsDataMgrService(tokenID, uid1);
741 EXPECT_EQ(ret, true);
742 idInner->type = Security::AccessToken::TOKEN_HAP;
743 ret = dataObsMgrServer->IsDataMgrService(tokenID, uid1);
744 EXPECT_EQ(ret, false);
745 TAG_LOGI(AAFwkTag::DBOBSMGR, "AaFwk_DataObsMgrServiceTest_GetDataMgrServiceUid_0100 end");
746 }
747
748 /*
749 * Feature: DataObsMgrService
750 * Function: GetDataMgrServiceUid
751 * SubFunction: NA
752 * FunctionPoints: DataObsMgrService GetDataMgrServiceUid
753 * EnvConditions: NA
754 * CaseDescription: Verify that the DataObsMgrService IsSystemApp is normal.
755 */
756 HWTEST_F(DataObsMgrServiceTest, AaFwk_DataObsMgrServiceTest_IsSystemApp_0100, TestSize.Level1)
757 {
758 TAG_LOGI(AAFwkTag::DBOBSMGR, "AaFwk_DataObsMgrServiceTest_IsSystemApp_0100 start");
759 auto dataObsMgrServer = std::make_shared<DataObsMgrService>();
760 auto originalToken = GetSelfTokenID();
761
762 // set system app
763 uint64_t systemAppMask = (static_cast<uint64_t>(1) << 32);
764 uint32_t tokenID = Security::AccessToken::DEFAULT_TOKEN_VERSION;
765 Security::AccessToken::AccessTokenIDInner *idInner =
766 reinterpret_cast<Security::AccessToken::AccessTokenIDInner *>(&tokenID);
767 idInner->type = Security::AccessToken::TOKEN_HAP;
768 uint64_t fullTokenId = systemAppMask | tokenID;
769
770 bool ret = dataObsMgrServer->IsSystemApp(tokenID, fullTokenId);
771 EXPECT_EQ(ret, true);
772 idInner->type = Security::AccessToken::TOKEN_NATIVE;
773 ret = dataObsMgrServer->IsSystemApp(tokenID, fullTokenId);
774 EXPECT_EQ(ret, false);
775 TAG_LOGI(AAFwkTag::DBOBSMGR, "AaFwk_DataObsMgrServiceTest_IsSystemApp_0100 end");
776 }
777
778 HWTEST_F(DataObsMgrServiceTest, AaFwk_DataObsMgrServiceTest_VerifyDataSharePermission_0100, TestSize.Level1)
779 {
780 TAG_LOGI(AAFwkTag::DBOBSMGR, "AaFwk_DataObsMgrServiceTest_VerifyDataSharePermission_0100 start");
781 auto dataObsMgrServer = std::make_shared<DataObsMgrService>();
782 std::string proxyUriOk = "datashareproxy://com.acts.datasharetest/test";
783 Uri uri(proxyUriOk);
784 ObserverInfo info(0, 0, 0, 0, true);
785 int32_t ret = dataObsMgrServer->VerifyDataSharePermission(uri, true, info);
786 EXPECT_EQ(ret, DataShare::E_NOT_HAP);
787 TAG_LOGI(AAFwkTag::DBOBSMGR, "AaFwk_DataObsMgrServiceTest_VerifyDataSharePermission_0100 end");
788 }
789
790 } // namespace AAFwk
791 } // namespace OHOS
792