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 #define private public
18 #include "dataobs_mgr_proxy.h"
19 #include "dataobs_mgr_client.h"
20 #include "mock_data_obs_manager_onchange_callback.h"
21 #include "mock_dataobs_mgr_service.h"
22 
23 using namespace testing::ext;
24 using namespace testing;
25 
26 namespace OHOS {
27 namespace AAFwk {
28 class DataObsMgrClientTest : public testing::Test {
29 public:
30     static void SetUpTestCase(void);
31     static void TearDownTestCase(void);
32     void SetUp();
33     void TearDown();
34 };
35 
SetUpTestCase(void)36 void DataObsMgrClientTest::SetUpTestCase(void)
37 {}
TearDownTestCase(void)38 void DataObsMgrClientTest::TearDownTestCase(void)
39 {}
SetUp()40 void DataObsMgrClientTest::SetUp()
41 {}
TearDown()42 void DataObsMgrClientTest::TearDown()
43 {}
44 
45 /*
46  * Feature: DataObsMgrClient.
47  * Function: The function of dataobsmgrservice was called.
48  * SubFunction: NA.
49  * FunctionPoints: NA.
50  * EnvConditions: NA.
51  * CaseDescription: NA.
52  */
53 HWTEST_F(DataObsMgrClientTest, DataObsMgrClient_Call_Service_0100, TestSize.Level1)
54 {
55     sptr<MockDataObsManagerOnChangeCallBack> callBack(new (std::nothrow) MockDataObsManagerOnChangeCallBack());
56 
57     auto client = DataObsMgrClient::GetInstance();
58     client->observers_.Clear();
59     client->observerExts_.Clear();
60 
61     sptr<MockDataObsMgrService> service(new (std::nothrow) MockDataObsMgrService());
62     client->dataObsManger_ = service;
63     EXPECT_TRUE(client->dataObsManger_ != nullptr);
64     Uri uri("datashare://device_id/com.domainname.dataability.persondata/person/25");
65     client->RegisterObserver(uri, callBack);
66     EXPECT_EQ(service->onChangeCall_, 1);
67 
68     client->UnregisterObserver(uri, callBack);
69     EXPECT_EQ(service->onChangeCall_, 2);
70 
71     client->NotifyChange(uri);
72     EXPECT_EQ(service->onChangeCall_, 3);
73 
74     client->RegisterObserverExt(uri, callBack, false);
75     EXPECT_EQ(service->onChangeCall_, 4);
76 
77     client->UnregisterObserverExt(uri, callBack);
78     EXPECT_EQ(service->onChangeCall_, 5);
79 
80     client->UnregisterObserverExt(callBack);
81     EXPECT_EQ(service->onChangeCall_, 6);
82 
83     client->NotifyChangeExt({ ChangeInfo::ChangeType::INSERT, { uri } });
84     EXPECT_EQ(service->onChangeCall_, 7);
85 
86     testing::Mock::AllowLeak(DataObsMgrClient::GetInstance()->dataObsManger_);
87 }
88 
89 /*
90  * Feature: DataObsMgrClient.
91  * Function: re-subscribe when service restart.
92  * SubFunction: NA.
93  * FunctionPoints: NA.
94  * EnvConditions: NA.
95  * CaseDescription: NA.
96  */
97 HWTEST_F(DataObsMgrClientTest, DataObsMgrClient_ReregisterObserver_0100, TestSize.Level1)
98 {
99     sptr<MockDataObsManagerOnChangeCallBack> callBack1(new (std::nothrow) MockDataObsManagerOnChangeCallBack());
100     sptr<MockDataObsManagerOnChangeCallBack> callBack2(new (std::nothrow) MockDataObsManagerOnChangeCallBack());
101 
102     auto client = DataObsMgrClient::GetInstance();
103     client->observers_.Clear();
104     client->observerExts_.Clear();
105 
106     sptr<MockDataObsMgrService> service1(new (std::nothrow) MockDataObsMgrService());
107     client->dataObsManger_ = service1;
108     EXPECT_TRUE(client->dataObsManger_ != nullptr);
109     Uri uri1("datashare://device_id/com.domainname.dataability.persondata/person/25");
110     Uri uri2("datashare://device_id/com.domainname.dataability.persondata/person/26");
111 
112     EXPECT_EQ(client->RegisterObserver(uri1, callBack1), NO_ERROR);
113     EXPECT_EQ(client->RegisterObserver(uri2, callBack2), NO_ERROR);
114     EXPECT_EQ(service1->onChangeCall_, 2);
115 
116     sptr<MockDataObsMgrService> service2(new (std::nothrow) MockDataObsMgrService());
117     client->dataObsManger_ = service2;
118     EXPECT_TRUE(client->dataObsManger_ != nullptr);
119 
120     client->ReRegister();
121     EXPECT_EQ(service2->onChangeCall_, 2);
122     testing::Mock::AllowLeak(DataObsMgrClient::GetInstance()->dataObsManger_);
123 }
124 
125 /*
126  * Feature: DataObsMgrClient.
127  * Function: re-subscribe when service restart.
128  * SubFunction: NA.
129  * FunctionPoints: NA.
130  * EnvConditions: NA.
131  * CaseDescription: NA.
132  */
133 HWTEST_F(DataObsMgrClientTest, DataObsMgrClient_ReregisterObserver_0200, TestSize.Level1)
134 {
135     sptr<MockDataObsManagerOnChangeCallBack> callBack1(new (std::nothrow) MockDataObsManagerOnChangeCallBack());
136     sptr<MockDataObsManagerOnChangeCallBack> callBack2(new (std::nothrow) MockDataObsManagerOnChangeCallBack());
137 
138     Uri uri1("datashare://device_id/com.domainname.dataability.persondata/person/1");
139     Uri uri2("datashare://device_id/com.domainname.dataability.persondata/person/2");
140     auto client = DataObsMgrClient::GetInstance();
141     client->observers_.Clear();
142     client->observerExts_.Clear();
143 
144     sptr<MockDataObsMgrService> service1(new (std::nothrow) MockDataObsMgrService());
145     client->dataObsManger_ = service1;
146     EXPECT_TRUE(client->dataObsManger_ != nullptr);
147 
148     EXPECT_EQ(client->RegisterObserverExt(uri1, callBack1, false), SUCCESS);
149     EXPECT_EQ(client->RegisterObserverExt(uri2, callBack2, true), SUCCESS);
150     EXPECT_EQ(service1->onChangeCall_, 2);
151 
152     sptr<MockDataObsMgrService> service2(new (std::nothrow) MockDataObsMgrService());
153     client->dataObsManger_ = service2;
154     EXPECT_TRUE(client->dataObsManger_ != nullptr);
155 
156     client->ReRegister();
157     EXPECT_EQ(service2->onChangeCall_, 2);
158     testing::Mock::AllowLeak(DataObsMgrClient::GetInstance()->dataObsManger_);
159 }
160 
161 /*
162  * Feature: DataObsMgrClient.
163  * Function: re-subscribe when service restart.
164  * SubFunction: NA.
165  * FunctionPoints: NA.
166  * EnvConditions: NA.
167  * CaseDescription: NA.
168  */
169 HWTEST_F(DataObsMgrClientTest, DataObsMgrClient_ReregisterObserver_0300, TestSize.Level1)
170 {
171     sptr<MockDataObsManagerOnChangeCallBack> callBack1(new (std::nothrow) MockDataObsManagerOnChangeCallBack());
172     sptr<MockDataObsManagerOnChangeCallBack> callBack2(new (std::nothrow) MockDataObsManagerOnChangeCallBack());
173 
174     auto client = DataObsMgrClient::GetInstance();
175     client->observers_.Clear();
176     client->observerExts_.Clear();
177 
178     sptr<MockDataObsMgrService> service1(new (std::nothrow) MockDataObsMgrService());
179     client->dataObsManger_ = service1;
180     EXPECT_TRUE(client->dataObsManger_ != nullptr);
181     Uri uri1("datashare://device_id/com.domainname.dataability.persondata/person/25");
182     Uri uri2("datashare://device_id/com.domainname.dataability.persondata/person/26");
183 
184     EXPECT_EQ(client->RegisterObserver(uri1, callBack1), NO_ERROR);
185     EXPECT_EQ(client->RegisterObserver(uri2, callBack2), NO_ERROR);
186     EXPECT_EQ(service1->onChangeCall_, 2);
187 
188     sptr<MockDataObsMgrService> service2(new (std::nothrow) MockDataObsMgrService());
189     client->dataObsManger_ = service2;
190     EXPECT_TRUE(client->dataObsManger_ != nullptr);
191 
192     client->OnRemoteDied();
193     EXPECT_EQ(service2->onChangeCall_, 0);
194     testing::Mock::AllowLeak(DataObsMgrClient::GetInstance()->dataObsManger_);
195 }
196 
197 }  // namespace AAFwk
198 }  // namespace OHOS
199