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 
17 #include "if_system_ability_manager.h"
18 #include "init_param.h"
19 #include "iservice_registry.h"
20 #include "iwatcher.h"
21 #include "iwatcher_manager.h"
22 #include "message_parcel.h"
23 #include "parameter.h"
24 #include "param_manager.h"
25 #include "param_stub.h"
26 #include "param_utils.h"
27 #include "system_ability_definition.h"
28 #include "watcher.h"
29 #include "watcher_manager_kits.h"
30 #include "watcher_manager_proxy.h"
31 #include "service_watcher.h"
32 
33 using namespace testing::ext;
34 using namespace std;
35 using namespace OHOS;
36 using namespace OHOS::init_param;
37 
38 int g_callbackCount = 0;
TestParameterChange(const char * key,const char * value,void * context)39 static void TestParameterChange(const char *key, const char *value, void *context)
40 {
41     printf("TestParameterChange key:%s %s \n", key, value);
42     g_callbackCount++;
43 }
44 
TestWatcherCallBack(const char * key,const ServiceInfo * status)45 static void TestWatcherCallBack(const char *key, const ServiceInfo *status)
46 {
47     printf("TestWatcherCallBack key:%s %d", key, status->status);
48 }
49 
50 class WatcherAgentUnitTest : public ::testing::Test {
51 public:
WatcherAgentUnitTest()52     WatcherAgentUnitTest() {}
~WatcherAgentUnitTest()53     virtual ~WatcherAgentUnitTest() {}
54 
SetUp()55     void SetUp()
56     {
57         if (GetParamSecurityLabel() != nullptr) {
58             GetParamSecurityLabel()->cred.uid = 1000;  // 1000 test uid
59             GetParamSecurityLabel()->cred.gid = 1000;  // 1000 test gid
60         }
61         SetTestPermissionResult(0);
62     }
TearDown()63     void TearDown() {}
TestBody()64     void TestBody() {}
65 
TestAddWatcher0(size_t index)66     int TestAddWatcher0(size_t index)
67     {
68         int ret = 0;
69         // has beed deleted
70         ret = RemoveParameterWatcher("test.permission.watcher.test1",
71             TestParameterChange, reinterpret_cast<void *>(index));
72         EXPECT_NE(ret, 0);
73 
74         // delete all
75         ret = SystemWatchParameter("test.permission.watcher.test1",
76             TestParameterChange, reinterpret_cast<void *>(index));
77         EXPECT_EQ(ret, 0);
78         index++;
79         ret = SystemWatchParameter("test.permission.watcher.test1",
80             TestParameterChange, reinterpret_cast<void *>(index));
81         EXPECT_EQ(ret, 0);
82         ret = RemoveParameterWatcher("test.permission.watcher.test1", nullptr, nullptr);
83         EXPECT_EQ(ret, 0);
84         // 非法
85         ret = SystemWatchParameter("test.permission.watcher.tes^^^^t1*", TestParameterChange, nullptr);
86         EXPECT_EQ(ret, PARAM_CODE_INVALID_NAME);
87         ret = SystemWatchParameter("test.permission.read.test1*", TestParameterChange, nullptr);
88         EXPECT_EQ(ret, DAC_RESULT_FORBIDED);
89         return ret;
90     }
TestAddWatcher()91     int TestAddWatcher()
92     {
93         size_t index = 1;
94         int ret = SystemWatchParameter("test.permission.watcher.test1",
95             TestParameterChange, reinterpret_cast<void *>(index));
96         EXPECT_EQ(ret, 0);
97         ret = SystemWatchParameter("test.permission.watcher.test1*",
98             TestParameterChange, reinterpret_cast<void *>(index));
99         EXPECT_EQ(ret, 0);
100         // repeat add, return fail
101         ret = SystemWatchParameter("test.permission.watcher.test1",
102             TestParameterChange, reinterpret_cast<void *>(index));
103         EXPECT_NE(ret, 0);
104         index++;
105         ret = SystemWatchParameter("test.permission.watcher.test1",
106             TestParameterChange, reinterpret_cast<void *>(index));
107         EXPECT_EQ(ret, 0);
108         index++;
109         ret = SystemWatchParameter("test.permission.watcher.test1",
110             TestParameterChange, reinterpret_cast<void *>(index));
111         EXPECT_EQ(ret, 0);
112 
113         // delete
114         ret = RemoveParameterWatcher("test.permission.watcher.test1",
115             TestParameterChange, reinterpret_cast<void *>(index));
116         EXPECT_EQ(ret, 0);
117         ret = RemoveParameterWatcher("test.permission.watcher.test1",
118             TestParameterChange, reinterpret_cast<void *>(index));
119         EXPECT_EQ(ret, 0);
120         index--;
121         ret = RemoveParameterWatcher("test.permission.watcher.test1",
122             TestParameterChange, reinterpret_cast<void *>(index));
123         EXPECT_EQ(ret, 0);
124         index--;
125         ret = RemoveParameterWatcher("test.permission.watcher.test1",
126             TestParameterChange, reinterpret_cast<void *>(index));
127         EXPECT_EQ(ret, 0);
128         return TestAddWatcher0(index);
129     }
130 
TestDelWatcher()131     int TestDelWatcher()
132     {
133         size_t index = 1;
134         int ret = SystemWatchParameter("test.permission.watcher.test3.1",
135             TestParameterChange, reinterpret_cast<void *>(index));
136         EXPECT_EQ(ret, 0);
137         ret = SystemWatchParameter("test.permission.watcher.test3.1*",
138             TestParameterChange, reinterpret_cast<void *>(index));
139         EXPECT_EQ(ret, 0);
140         ret = SystemWatchParameter("test.permission.watcher.test3.2",
141             TestParameterChange, reinterpret_cast<void *>(index));
142         EXPECT_EQ(ret, 0);
143         ret = SystemWatchParameter("test.permission.watcher.test3.2", TestParameterChange,
144             reinterpret_cast<void *>(index));
145         EXPECT_EQ(ret, PARAM_WATCHER_CALLBACK_EXIST);
146         ret = SystemWatchParameter("test.permission.watcher.test3.1", nullptr, nullptr);
147         EXPECT_EQ(ret, 0);
148         ret = SystemWatchParameter("test.permission.watcher.test3.1*", nullptr, nullptr);
149         EXPECT_EQ(ret, 0);
150         ret = SystemWatchParameter("test.permission.watcher.test3.2", nullptr, nullptr);
151         EXPECT_EQ(ret, 0);
152 
153         // 非法
154         ret = SystemWatchParameter("test.permission.watcher.tes^^^^t1*", nullptr, nullptr);
155         EXPECT_EQ(ret, PARAM_CODE_INVALID_NAME);
156         ret = SystemWatchParameter("test.permission.read.test1*", nullptr, nullptr);
157         EXPECT_EQ(ret, DAC_RESULT_FORBIDED);
158         return 0;
159     }
160 
TestRecvMessage(const std::string & name)161     int TestRecvMessage(const std::string &name)
162     {
163         MessageParcel data;
164         MessageParcel reply;
165         MessageOption option;
166         data.WriteInterfaceToken(IWatcher::GetDescriptor());
167         data.WriteString(name);
168         data.WriteString(name);
169         data.WriteString("watcherId");
170         g_callbackCount = 0;
171         int ret = SystemWatchParameter(name.c_str(), TestParameterChange, nullptr);
172         EXPECT_EQ(ret, 0);
173         WatcherManagerKits &instance = OHOS::init_param::WatcherManagerKits::GetInstance();
174         if (instance.remoteWatcher_ != nullptr) {
175             instance.remoteWatcher_->OnRemoteRequest(IWatcher::PARAM_CHANGE, data, reply, option);
176             instance.remoteWatcher_->OnRemoteRequest(IWatcher::PARAM_CHANGE + 1, data, reply, option);
177             instance.remoteWatcher_->OnParameterChange(name.c_str(), "testname", "testvalue");
178             EXPECT_EQ(g_callbackCount, 2); // 2 is callback Count
179             instance.remoteWatcher_->OnParameterChange(name.c_str(), "testname.2", "testvalue");
180             EXPECT_EQ(g_callbackCount, 3); // 3 is callback Count
181             instance.remoteWatcher_->OnParameterChange(name.c_str(), "testname.2", "testvalue");
182             EXPECT_EQ(g_callbackCount, 3); // 3 is callback Count
183 
184             // prefix not exit
185             instance.remoteWatcher_->OnParameterChange("44444444444444444444", "testname.2", "testvalue");
186         }
187         EXPECT_EQ(g_callbackCount, 3); // 3 is callback Count
188         return 0;
189     }
190 
TestResetService()191     int TestResetService()
192     {
193         sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
194         WATCHER_CHECK(samgr != nullptr, return -1, "Get samgr failed");
195         sptr<IRemoteObject> object = samgr->GetSystemAbility(PARAM_WATCHER_DISTRIBUTED_SERVICE_ID);
196         WATCHER_CHECK(object != nullptr, return -1, "Get watcher manager object from samgr failed");
197         OHOS::init_param::WatcherManagerKits &instance = OHOS::init_param::WatcherManagerKits::GetInstance();
198         if (instance.GetDeathRecipient() != nullptr) {
199             instance.GetDeathRecipient()->OnRemoteDied(object);
200         }
201         return 0;
202     }
203 
TestWatcherProxy()204     void TestWatcherProxy()
205     {
206         sptr<WatcherManagerProxy> watcherManager = new(std::nothrow) WatcherManagerProxy(nullptr);
207         ASSERT_NE(watcherManager, nullptr);
208 
209         WatcherManagerKits &instance = OHOS::init_param::WatcherManagerKits::GetInstance();
210         sptr<Watcher> remoteWatcher = new OHOS::init_param::WatcherManagerKits::RemoteWatcher(&instance);
211         ASSERT_NE(remoteWatcher, nullptr);
212 
213         MessageParcel data;
214         MessageParcel reply;
215         MessageOption option;
216         data.WriteInterfaceToken(IWatcher::GetDescriptor());
217         data.WriteString("name");
218         data.WriteString("name");
219         data.WriteString("watcherId");
220         remoteWatcher->OnRemoteRequest(IWatcher::PARAM_CHANGE, data, reply, option);
221 
222         // invalid parameter
223         data.WriteInterfaceToken(IWatcher::GetDescriptor());
224         data.WriteString("name");
225         data.WriteString("watcherId");
226         remoteWatcher->OnRemoteRequest(IWatcher::PARAM_CHANGE, data, reply, option);
227 
228         data.WriteInterfaceToken(IWatcher::GetDescriptor());
229         data.WriteString("name");
230         remoteWatcher->OnRemoteRequest(IWatcher::PARAM_CHANGE, data, reply, option);
231 
232         data.WriteInterfaceToken(IWatcher::GetDescriptor());
233         remoteWatcher->OnRemoteRequest(IWatcher::PARAM_CHANGE, data, reply, option);
234 
235         data.WriteInterfaceToken(IWatcher::GetDescriptor());
236         data.WriteString("name");
237         data.WriteString("name");
238         data.WriteString("watcherId");
239         remoteWatcher->OnRemoteRequest(IWatcher::PARAM_CHANGE + 1, data, reply, option);
240         remoteWatcher->OnRemoteRequest(IWatcher::PARAM_CHANGE + 1, data, reply, option);
241 
242         uint32_t watcherId = watcherManager->AddRemoteWatcher(1000, remoteWatcher);
243         // add watcher
244         int ret = watcherManager->AddWatcher("test.watcher.proxy", watcherId);
245         ASSERT_EQ(ret, 0);
246         ret = watcherManager->DelWatcher("test.watcher.proxy", watcherId);
247         ASSERT_EQ(ret, 0);
248         ret = watcherManager->RefreshWatcher("test.watcher.proxy", watcherId);
249         ASSERT_EQ(ret, 0);
250         watcherManager->DelRemoteWatcher(watcherId);
251     }
252 };
253 
254 HWTEST_F(WatcherAgentUnitTest, Init_TestAddWatcher_001, TestSize.Level0)
255 {
256     WatcherAgentUnitTest test;
257     test.TestAddWatcher();
258 }
259 
260 HWTEST_F(WatcherAgentUnitTest, Init_TestRecvMessage_001, TestSize.Level0)
261 {
262     WatcherAgentUnitTest test;
263     test.TestRecvMessage("test.permission.watcher.agent.test1");
264 }
265 
266 HWTEST_F(WatcherAgentUnitTest, Init_TestDelWatcher_001, TestSize.Level0)
267 {
268     WatcherAgentUnitTest test;
269     test.TestDelWatcher();
270 }
271 
272 HWTEST_F(WatcherAgentUnitTest, Init_TestResetService_001, TestSize.Level0)
273 {
274     WatcherAgentUnitTest test;
275     test.TestResetService();
276 }
277 
278 HWTEST_F(WatcherAgentUnitTest, Init_TestWatcherService_001, TestSize.Level0)
279 {
280     const char *errstr = "111111111111111111111111111111111111111111111111111111111111111111111111111111111111";
281     ServiceWatchForStatus("param_watcher", TestWatcherCallBack);
282     ServiceWaitForStatus("param_watcher", SERVICE_STARTED, 1);
283     EXPECT_NE(ServiceWatchForStatus(errstr, TestWatcherCallBack), 0);
284     EXPECT_NE(ServiceWatchForStatus(nullptr, TestWatcherCallBack), 0);
285     WatchParameter("testParam", nullptr, nullptr);
286     WatchParameter(nullptr, nullptr, nullptr);
287 }
288 
289 HWTEST_F(WatcherAgentUnitTest, Init_TestInvalidWatcher_001, TestSize.Level0)
290 {
291     int ret = SystemWatchParameter(nullptr, TestParameterChange, nullptr);
292     ASSERT_NE(ret, 0);
293     ret = RemoveParameterWatcher(nullptr, nullptr, nullptr);
294     ASSERT_NE(ret, 0);
295 }
296 
297 HWTEST_F(WatcherAgentUnitTest, Init_TestWatcherProxy_001, TestSize.Level0)
298 {
299     WatcherAgentUnitTest test;
300     test.TestWatcherProxy();
301 }
302