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 <gtest/gtest.h>
16 #include <memory>
17 #include <algorithm>
18 #include <functional>
19 #include "uri.h"
20 #define private public
21 #include "data_ability_observer_proxy.h"
22 #include "dataobs_mgr_errors.h"
23 #include "dataobs_mgr_inner.h"
24 #include "hilog_tag_wrapper.h"
25 #include "mock_data_ability_observer_stub.h"
26
27 using namespace OHOS;
28 using namespace testing::ext;
29 using namespace testing;
30
31
32 namespace OHOS {
33 namespace AAFwk {
34 using Uri = OHOS::Uri;
35 using ObsListType = std::list<struct ObserverNode>;
36 using ObsRecipientMapType = OHOS::AAFwk::DataObsMgrInner::ObsRecipientMapType;
37 class DataObsMgrInnerTest : public testing::Test {
38 public:
39 static void SetUpTestCase(void);
40 static void TearDownTestCase(void);
41 void SetUp();
42 void TearDown();
43 std::shared_ptr<DataObsMgrInner> dataObsMgrInner_ = nullptr;
44 };
SetUpTestCase(void)45 void DataObsMgrInnerTest::SetUpTestCase(void) {}
TearDownTestCase(void)46 void DataObsMgrInnerTest::TearDownTestCase(void) {}
SetUp()47 void DataObsMgrInnerTest::SetUp()
48 {
49 dataObsMgrInner_ = std::make_shared<DataObsMgrInner>();
50 }
TearDown()51 void DataObsMgrInnerTest::TearDown() {}
52
53 static constexpr int64_t USER_TEST = 100;
54
55 /*
56 * Feature: DataObsMgrInner
57 * Function: Register and unregister function test
58 * SubFunction: HandleRegisterObserver/HandleRegisterObserver
59 * FunctionPoints: NA
60 * EnvConditions: NA
61 * CaseDescription:NA
62 */
63 HWTEST_F(DataObsMgrInnerTest, DataObsMgrInner_HandleRegisterObserver_0100, TestSize.Level1)
64 {
65 if (dataObsMgrInner_ == nullptr) {
66 return;
67 }
68
69 Uri uri("dataability://device_id/com.domainname.dataability.persondata/person/10");
70 sptr<MockDataAbilityObserverStub> observer(new (std::nothrow) MockDataAbilityObserverStub());
71
72 const sptr<IDataAbilityObserver> callback(new (std::nothrow) DataAbilityObserverProxy(observer));
73 dataObsMgrInner_->HandleRegisterObserver(uri, ObserverNode(callback, USER_TEST, 0));
74
75 EXPECT_EQ(dataObsMgrInner_->HaveRegistered(callback), true);
76 dataObsMgrInner_->HandleUnregisterObserver(uri, ObserverNode(callback, USER_TEST, 0));
77 EXPECT_EQ(dataObsMgrInner_->HaveRegistered(callback), false);
78 }
79
80 /*
81 * Feature: DataObsMgrInner
82 * Function: Register function test
83 * SubFunction: HandleRegisterObserver
84 * FunctionPoints: NA
85 * EnvConditions: NA
86 * CaseDescription:NA
87 */
88 HWTEST_F(DataObsMgrInnerTest, DataObsMgrInner_HandleRegisterObserver_0200, TestSize.Level1)
89 {
90 std::shared_ptr<DataObsMgrInner> dataObsMgrInner = std::make_shared<DataObsMgrInner>();
91 Uri uri("dataability://device_id/com.domainname.dataability.persondata/person/10");
92 sptr<MockDataAbilityObserverStub> observer(new (std::nothrow) MockDataAbilityObserverStub());
93 const sptr<IDataAbilityObserver> callback(new (std::nothrow) DataAbilityObserverProxy(observer));
94 ObsListType obsList;
95 obsList.push_back(ObserverNode(callback, USER_TEST, 0));
96 dataObsMgrInner->observers_.emplace(uri.ToString(), obsList);
97 int res = dataObsMgrInner->HandleRegisterObserver(uri, ObserverNode(callback, USER_TEST, 0));
98 EXPECT_EQ(res, OBS_EXIST);
99 }
100
101 /*
102 * Feature: DataObsMgrInner
103 * Function: Register function test
104 * SubFunction: HandleRegisterObserver
105 * FunctionPoints: NA
106 * EnvConditions: NA
107 * CaseDescription:NA
108 */
109 HWTEST_F(DataObsMgrInnerTest, DataObsMgrInner_HandleRegisterObserver_0300, TestSize.Level1)
110 {
111 std::shared_ptr<DataObsMgrInner> dataObsMgrInner = std::make_shared<DataObsMgrInner>();
112 Uri uri("dataability://device_id/com.domainname.dataability.persondata/person/10");
113 sptr<MockDataAbilityObserverStub> observer(new (std::nothrow) MockDataAbilityObserverStub());
114 const sptr<IDataAbilityObserver> callback(new (std::nothrow) DataAbilityObserverProxy(observer));
115 const sptr<IDataAbilityObserver> callback1(new (std::nothrow) DataAbilityObserverProxy(observer));
116 ObsListType obsList;
117 obsList.push_back(ObserverNode(callback1, USER_TEST, 0));
118 dataObsMgrInner->observers_.emplace(uri.ToString(), obsList);
119 int res = dataObsMgrInner->HandleRegisterObserver(uri, ObserverNode(callback, USER_TEST, 0));
120 EXPECT_EQ(res, OBS_EXIST);
121 }
122
123 /*
124 * Feature: DataObsMgrInner
125 * Function: Register function test
126 * SubFunction: HandleRegisterObserver
127 * FunctionPoints: NA
128 * EnvConditions: NA
129 * CaseDescription: RegisterObserver max limit times
130 */
131 HWTEST_F(DataObsMgrInnerTest, DataObsMgrInner_HandleRegisterObserver_0400, TestSize.Level1)
132 {
133 std::shared_ptr<DataObsMgrInner> dataObsMgrInner = std::make_shared<DataObsMgrInner>();
134 Uri uri("dataability://device_id/com.domainname.dataability.persondata/person/10");
135 int times = DataObsMgrInner::OBS_NUM_MAX;
136 for (int i = 0; i <= times; i++) {
137 sptr<MockDataAbilityObserverStub> observer(new (std::nothrow) MockDataAbilityObserverStub());
138 const sptr<IDataAbilityObserver> callback(new (std::nothrow) DataAbilityObserverProxy(observer));
139 int res = dataObsMgrInner->HandleRegisterObserver(uri, ObserverNode(callback, USER_TEST, 0));
140 EXPECT_EQ(res, NO_ERROR);
141 }
142 sptr<MockDataAbilityObserverStub> observer(new (std::nothrow) MockDataAbilityObserverStub());
143 const sptr<IDataAbilityObserver> callback(new (std::nothrow) DataAbilityObserverProxy(observer));
144 int res = dataObsMgrInner->HandleRegisterObserver(uri, ObserverNode(callback, USER_TEST, 0));
145 EXPECT_EQ(res, DATAOBS_SERVICE_OBS_LIMMIT);
146
147 // other token success
148 sptr<MockDataAbilityObserverStub> observer2(new (std::nothrow) MockDataAbilityObserverStub());
149 res = dataObsMgrInner->HandleRegisterObserver(uri, ObserverNode(callback, USER_TEST, 1));
150 EXPECT_EQ(res, SUCCESS);
151
152 // other uri success
153 Uri uri2("dataability://device_id/com.domainname.dataability.persondata/person/11");
154 sptr<MockDataAbilityObserverStub> observer3(new (std::nothrow) MockDataAbilityObserverStub());
155 res = dataObsMgrInner->HandleRegisterObserver(uri2, ObserverNode(callback, USER_TEST, 0));
156 EXPECT_EQ(res, SUCCESS);
157 }
158
159 /*
160 * Feature: DataObsMgrInner
161 * Function: Register function test
162 * SubFunction: HandleRegisterObserver
163 * FunctionPoints: NA
164 * EnvConditions: NA
165 * CaseDescription: RegisterObserver max limit times
166 */
167 HWTEST_F(DataObsMgrInnerTest, DataObsMgrInner_HandleRegisterObserver_0500, TestSize.Level1)
168 {
169 TAG_LOGE(AAFwkTag::DBOBSMGR, "DataObsMgrInner_HandleRegisterObserver_0500::Start");
170 std::shared_ptr<DataObsMgrInner> dataObsMgrInner = std::make_shared<DataObsMgrInner>();
171 Uri uri("dataability://device_id/com.domainname.dataability.persondata/person/10");
172 for (int token = 0; token < DataObsMgrInner::OBS_NUM_MAX; token++) {
173 for (int i = 0; i < DataObsMgrInner::OBS_NUM_MAX; i++) {
174 sptr<MockDataAbilityObserverStub> observer(new (std::nothrow) MockDataAbilityObserverStub());
175 const sptr<IDataAbilityObserver> callback(new (std::nothrow) DataAbilityObserverProxy(observer));
176 int res = dataObsMgrInner->HandleRegisterObserver(uri, ObserverNode(callback, USER_TEST, token));
177 EXPECT_EQ(res, NO_ERROR);
178 }
179 }
180 int token = DataObsMgrInner::OBS_NUM_MAX + 1;
181 sptr<MockDataAbilityObserverStub> observer(new (std::nothrow) MockDataAbilityObserverStub());
182 const sptr<IDataAbilityObserver> callback(new (std::nothrow) DataAbilityObserverProxy(observer));
183 int res = dataObsMgrInner->HandleRegisterObserver(uri, ObserverNode(callback, USER_TEST, token));
184 EXPECT_EQ(res, DATAOBS_SERVICE_OBS_LIMMIT);
185 TAG_LOGE(AAFwkTag::DBOBSMGR, "DataObsMgrInner_HandleRegisterObserver_0500::End");
186 }
187
188 /*
189 * Feature: DataObsMgrInner
190 * Function: Unregister function test
191 * SubFunction: HandleUnregisterObserver
192 * FunctionPoints: NA
193 * EnvConditions: NA
194 * CaseDescription:NA
195 */
196 HWTEST_F(DataObsMgrInnerTest, DataObsMgrInner_HandleUnregisterObserver_0100, TestSize.Level1)
197 {
198 std::shared_ptr<DataObsMgrInner> dataObsMgrInner = std::make_shared<DataObsMgrInner>();
199 Uri uri("dataability://device_id/com.domainname.dataability.persondata/person/10");
200 sptr<MockDataAbilityObserverStub> observer(new (std::nothrow) MockDataAbilityObserverStub());
201 const sptr<IDataAbilityObserver> callback(new (std::nothrow) DataAbilityObserverProxy(observer));
202 dataObsMgrInner->observers_.clear();
203 int res = dataObsMgrInner->HandleUnregisterObserver(uri, ObserverNode(callback, USER_TEST, 0));
204 EXPECT_EQ(res, NO_OBS_FOR_URI);
205 }
206
207 /*
208 * Feature: DataObsMgrInner
209 * Function: Unregister function test
210 * SubFunction: HandleUnregisterObserver
211 * FunctionPoints: NA
212 * EnvConditions: NA
213 * CaseDescription:NA
214 */
215 HWTEST_F(DataObsMgrInnerTest, DataObsMgrInner_HandleUnregisterObserver_0200, TestSize.Level1)
216 {
217 std::shared_ptr<DataObsMgrInner> dataObsMgrInner = std::make_shared<DataObsMgrInner>();
218 Uri uri("dataability://device_id/com.domainname.dataability.persondata/person/10");
219 sptr<MockDataAbilityObserverStub> observer(new (std::nothrow) MockDataAbilityObserverStub());
220 const sptr<IDataAbilityObserver> callback(new (std::nothrow) DataAbilityObserverProxy(observer));
221 ObsListType obsList;
222 obsList.push_back(ObserverNode(callback, USER_TEST, 0));
223 dataObsMgrInner->observers_.emplace(uri.ToString(), obsList);
224 int res = dataObsMgrInner->HandleUnregisterObserver(uri, ObserverNode(callback, USER_TEST, 0));
225 EXPECT_EQ(res, NO_ERROR);
226 }
227
228 /*
229 * Feature: DataObsMgrInner
230 * Function: Unregister function test
231 * SubFunction: HandleUnregisterObserver
232 * FunctionPoints: NA
233 * EnvConditions: NA
234 * CaseDescription:NA
235 */
236 HWTEST_F(DataObsMgrInnerTest, DataObsMgrInner_HandleUnregisterObserver_0300, TestSize.Level1)
237 {
238 std::shared_ptr<DataObsMgrInner> dataObsMgrInner = std::make_shared<DataObsMgrInner>();
239 Uri uri("dataability://device_id/com.domainname.dataability.persondata/person/10");
240 sptr<MockDataAbilityObserverStub> observer(new (std::nothrow) MockDataAbilityObserverStub());
241 const sptr<IDataAbilityObserver> callback(new (std::nothrow) DataAbilityObserverProxy(observer));
242 const sptr<IDataAbilityObserver> callback2(new (std::nothrow) DataAbilityObserverProxy(observer));
243 ObsListType obsList;
244 obsList.push_back(ObserverNode(callback, USER_TEST, 0));
245 obsList.push_back(ObserverNode(callback2, USER_TEST, 0));
246 dataObsMgrInner->observers_.emplace(uri.ToString(), obsList);
247 dataObsMgrInner->observers_.emplace("exit", obsList);
248 int res = dataObsMgrInner->HandleUnregisterObserver(uri, ObserverNode(callback, USER_TEST, 0));
249 EXPECT_EQ(res, NO_ERROR);
250 }
251
252 /*
253 * Feature: DataObsMgrInner
254 * Function: Register and unregister function test
255 * SubFunction: OnChange
256 * FunctionPoints: When the data changes, call the OnChange function of the registered dataabilityobserver
257 * EnvConditions: NA
258 * CaseDescription:NA
259 */
260 HWTEST_F(DataObsMgrInnerTest, DataObsMgrInner_HandleNotifyChange_0100, TestSize.Level1)
261 {
262 if (dataObsMgrInner_ == nullptr) {
263 return;
264 }
265 Uri uri("dataability://device_id/com.domainname.dataability.persondata/person/10");
266 sptr<MockDataAbilityObserverStub> mockDataAbilityObserverStub(new (std::nothrow) MockDataAbilityObserverStub());
267
268 EXPECT_CALL(*mockDataAbilityObserverStub, OnChange()).Times(1);
269
270 const sptr<IDataAbilityObserver> callback(new (std::nothrow) DataAbilityObserverProxy(mockDataAbilityObserverStub));
271 dataObsMgrInner_->HandleRegisterObserver(uri, ObserverNode(callback, USER_TEST, 0));
272 dataObsMgrInner_->HandleNotifyChange(uri, USER_TEST);
273 }
274
275 /*
276 * Feature: DataObsMgrInner
277 * Function: Unregister function test
278 * SubFunction: HandleUnregisterObserver
279 * FunctionPoints: NA
280 * EnvConditions: NA
281 * CaseDescription:NA
282 */
283 HWTEST_F(DataObsMgrInnerTest, DataObsMgrInner_HandleNotifyChange_0200, TestSize.Level1)
284 {
285 std::shared_ptr<DataObsMgrInner> dataObsMgrInner = std::make_shared<DataObsMgrInner>();
286 Uri uri("dataability://device_id/com.domainname.dataability.persondata/person/10");
287 dataObsMgrInner->observers_.clear();
288 int res = dataObsMgrInner->HandleNotifyChange(uri, USER_TEST);
289 EXPECT_EQ(res, NO_OBS_FOR_URI);
290 }
291
292 /*
293 * Feature: DataObsMgrInner
294 * Function: Unregister function test
295 * SubFunction: HandleUnregisterObserver
296 * FunctionPoints: NA
297 * EnvConditions: NA
298 * CaseDescription:NA
299 */
300 HWTEST_F(DataObsMgrInnerTest, DataObsMgrInner_HandleNotifyChange_0300, TestSize.Level1)
301 {
302 std::shared_ptr<DataObsMgrInner> dataObsMgrInner = std::make_shared<DataObsMgrInner>();
303 Uri uri("dataability://device_id/com.domainname.dataability.persondata/person/10");
304 ObsListType obsList;
305 obsList.push_back(ObserverNode(nullptr, USER_TEST, 0));
306 dataObsMgrInner->observers_.emplace(uri.ToString(), obsList);
307 int res = dataObsMgrInner->HandleNotifyChange(uri, USER_TEST);
308 EXPECT_EQ(res, NO_ERROR);
309 }
310
311 /*
312 * Feature: DataObsMgrInner
313 * Function: GetObsListFromMap/RemoveObs/HaveRegistered function test
314 * SubFunction: NA
315 * FunctionPoints: NA
316 * EnvConditions: NA
317 * CaseDescription:NA
318 */
319 HWTEST_F(DataObsMgrInnerTest, DataObsMgrInner_RemoveObs_HaveRegistered_0100, TestSize.Level1)
320 {
321 if (dataObsMgrInner_ == nullptr) {
322 return;
323 }
324 Uri uri("dataability://device_id/com.domainname.dataability.persondata/person/10");
325 sptr<MockDataAbilityObserverStub> mockDataAbilityObserverStub(new (std::nothrow) MockDataAbilityObserverStub());
326 const sptr<IDataAbilityObserver> callback(new (std::nothrow) DataAbilityObserverProxy(mockDataAbilityObserverStub));
327 dataObsMgrInner_->HandleRegisterObserver(uri, ObserverNode(callback, USER_TEST, 0));
328
329 sptr<MockDataAbilityObserverStub> mockDataAbilityObserverStub2(new (std::nothrow) MockDataAbilityObserverStub());
330 const sptr<IDataAbilityObserver> callback2(
331 new (std::nothrow) DataAbilityObserverProxy(mockDataAbilityObserverStub2));
332
333 dataObsMgrInner_->HandleRegisterObserver(uri, ObserverNode(callback2, USER_TEST, 0));
334 auto obsPair = dataObsMgrInner_->observers_.find(uri.ToString());
335 EXPECT_EQ((std::size_t)2, obsPair->second.size());
336 EXPECT_EQ(true, dataObsMgrInner_->HaveRegistered(callback));
337 EXPECT_EQ(true, dataObsMgrInner_->HaveRegistered(callback2));
338
339 dataObsMgrInner_->RemoveObs(callback->AsObject());
340 EXPECT_EQ(false, dataObsMgrInner_->HaveRegistered(callback));
341 obsPair->second.clear();
342 obsPair = dataObsMgrInner_->observers_.find(uri.ToString());
343 EXPECT_EQ(false, dataObsMgrInner_->HaveRegistered(callback));
344
345 dataObsMgrInner_->RemoveObs(callback2->AsObject());
346 EXPECT_EQ(false, dataObsMgrInner_->HaveRegistered(callback2));
347 obsPair->second.clear();
348 obsPair = dataObsMgrInner_->observers_.find(uri.ToString());
349 EXPECT_EQ(false, dataObsMgrInner_->HaveRegistered(callback2));
350 }
351
352 /*
353 * Feature: DataObsMgrInner
354 * Function: AddObsDeathRecipient/RemoveObsDeathRecipient function test
355 * SubFunction: NA
356 * FunctionPoints: NA
357 * EnvConditions: NA
358 * CaseDescription:NA
359 */
360 HWTEST_F(DataObsMgrInnerTest, DataObsMgrInner_AddRemove_ObsDeathRecipient_0100, TestSize.Level1)
361 {
362 if (dataObsMgrInner_ == nullptr) {
363 return;
364 }
365
366 sptr<IRemoteObject> observer(new (std::nothrow) MockDataAbilityObserverStub());
367 sptr<IDataAbilityObserver> callback(new (std::nothrow) DataAbilityObserverProxy(observer));
368 dataObsMgrInner_->AddObsDeathRecipient(callback);
369 dataObsMgrInner_->AddObsDeathRecipient(nullptr);
370
371 ObsRecipientMapType::const_iterator it;
372 it = dataObsMgrInner_->obsRecipient_.find(observer);
373 EXPECT_EQ(true, it != dataObsMgrInner_->obsRecipient_.end());
374
375 dataObsMgrInner_->RemoveObsDeathRecipient(callback->AsObject());
376 dataObsMgrInner_->RemoveObsDeathRecipient(nullptr);
377 it = dataObsMgrInner_->obsRecipient_.find(observer);
378 EXPECT_EQ(false, it != dataObsMgrInner_->obsRecipient_.end());
379
380 dataObsMgrInner_->obsRecipient_.clear();
381 dataObsMgrInner_->RemoveObsDeathRecipient(callback->AsObject());
382 }
383
384 /*
385 * Feature: DataObsMgrInner
386 * Function: Unregister function test
387 * SubFunction: RemoveObs
388 * FunctionPoints: NA
389 * EnvConditions: NA
390 * CaseDescription:NA
391 */
392 HWTEST_F(DataObsMgrInnerTest, DataObsMgrInner_RemoveObs_0100, TestSize.Level1)
393 {
394 std::shared_ptr<DataObsMgrInner> dataObsMgrInner = std::make_shared<DataObsMgrInner>();
395 ASSERT_NE(dataObsMgrInner, nullptr);
396 std::string uri1 = "uri1";
397 std::string uri2 = "uri2";
398 sptr<MockDataAbilityObserverStub> observer(new (std::nothrow) MockDataAbilityObserverStub());
399 const sptr<IDataAbilityObserver> callback1(new (std::nothrow) DataAbilityObserverProxy(observer));
400 const sptr<IDataAbilityObserver> callback2(new (std::nothrow) DataAbilityObserverProxy(observer));
401 ObsListType obsList1;
402 ObsListType obsList2;
403 ObsListType obsList3;
404 obsList1.push_back(ObserverNode(callback1, USER_TEST, 0));
405 obsList2.push_back(ObserverNode(callback1, USER_TEST, 0));
406 obsList2.push_back(ObserverNode(callback2, USER_TEST, 0));
407 dataObsMgrInner->observers_.emplace(uri1, obsList1);
408 dataObsMgrInner->observers_.emplace(uri2, obsList2);
409 dataObsMgrInner->RemoveObs(callback2->AsObject());
410 }
411 } // namespace AAFwk
412 } // namespace OHOS
413