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 "param_stub.h"
19 #include "iservice_registry.h"
20 #include "iwatcher.h"
21 #include "iwatcher_manager.h"
22 #include "message_parcel.h"
23 #include "param_message.h"
24 #include "init_param.h"
25 #include "param_utils.h"
26 #include "parcel.h"
27 #include "securec.h"
28 #include "system_ability_definition.h"
29 #include "string_ex.h"
30 #include "watcher.h"
31 #include "watcher_manager.h"
32 #include "watcher_proxy.h"
33 #include "watcher_utils.h"
34 
35 using namespace testing::ext;
36 using namespace std;
37 using namespace OHOS;
38 using namespace OHOS::init_param;
39 
40 class TestWatcher final : public Watcher {
41 public:
TestWatcher()42     TestWatcher() {}
43     ~TestWatcher() = default;
44 
OnParameterChange(const std::string & prefix,const std::string & name,const std::string & value)45     void OnParameterChange(const std::string &prefix, const std::string &name, const std::string &value) override
46     {
47         printf("TestWatcher::OnParameterChange name %s %s \n", name.c_str(), value.c_str());
48     }
49 };
50 
51 using WatcherManagerPtr = WatcherManager *;
52 class WatcherProxyUnitTest : public ::testing::Test {
53 public:
WatcherProxyUnitTest()54     WatcherProxyUnitTest() {}
~WatcherProxyUnitTest()55     virtual ~WatcherProxyUnitTest() {}
56 
SetUp()57     void SetUp()
58     {
59         if (GetParamSecurityLabel() != nullptr) {
60             GetParamSecurityLabel()->cred.uid = 0;
61             GetParamSecurityLabel()->cred.gid = 0;
62         }
63         SetTestPermissionResult(0);
64     }
TearDown()65     void TearDown() {}
TestBody()66     void TestBody() {}
67 
TestAddRemoteWatcher(uint32_t agentId,uint32_t & watcherId)68     int TestAddRemoteWatcher(uint32_t agentId, uint32_t &watcherId)
69     {
70         WatcherManagerPtr watcherManager = GetWatcherManager();
71         WATCHER_CHECK(watcherManager != nullptr, return -1, "Failed to create manager");
72         MessageParcel data;
73         MessageParcel reply;
74         MessageOption option;
75 
76         data.WriteInterfaceToken(IWatcherManager::GetDescriptor());
77         sptr<IWatcher> watcher = new TestWatcher();
78         bool ret = data.WriteRemoteObject(watcher->AsObject());
79         WATCHER_CHECK(ret, return 0, "Can not get remote");
80         data.WriteUint32(agentId);
81         watcherManager->OnRemoteRequest(
82             static_cast<uint32_t> (ParamWatcherInterfaceCode::ADD_REMOTE_AGENT), data, reply, option);
83         watcherId = reply.ReadUint32();
84         EXPECT_NE(watcherId, 0);
85 
86         auto remoteWatcher = watcherManager->GetRemoteWatcher(watcherId);
87         if (remoteWatcher != nullptr) {
88             EXPECT_EQ(remoteWatcher->GetAgentId(), agentId);
89         } else {
90             EXPECT_EQ(0, agentId);
91         }
92         return 0;
93     }
94 
TestDelRemoteWatcher(uint32_t watcherId)95     int TestDelRemoteWatcher(uint32_t watcherId)
96     {
97         WatcherManagerPtr watcherManager = GetWatcherManager();
98         WATCHER_CHECK(watcherManager != nullptr, return -1, "Failed to create manager");
99         MessageParcel data;
100         MessageParcel reply;
101         MessageOption option;
102 
103         data.WriteInterfaceToken(IWatcherManager::GetDescriptor());
104         data.WriteUint32(watcherId);
105         watcherManager->OnRemoteRequest(
106             static_cast<uint32_t> (ParamWatcherInterfaceCode::DEL_REMOTE_AGENT), data, reply, option);
107         EXPECT_EQ(reply.ReadInt32(), 0);
108         EXPECT_EQ(watcherManager->GetRemoteWatcher(watcherId) == nullptr, 1);
109         return 0;
110     }
111 
TestAddWatcher(const std::string & keyPrefix,uint32_t watcherId)112     int TestAddWatcher(const std::string &keyPrefix, uint32_t watcherId)
113     {
114         WatcherManagerPtr watcherManager = GetWatcherManager();
115         WATCHER_CHECK(watcherManager != nullptr, return -1, "Failed to create manager");
116         MessageParcel data;
117         MessageParcel reply;
118         MessageOption option;
119 
120         data.WriteInterfaceToken(IWatcherManager::GetDescriptor());
121         data.WriteString(keyPrefix);
122         data.WriteUint32(watcherId);
123         watcherManager->OnRemoteRequest(
124             static_cast<uint32_t> (ParamWatcherInterfaceCode::ADD_WATCHER), data, reply, option);
125         EXPECT_EQ(reply.ReadInt32(), 0);
126         EXPECT_EQ(watcherManager->GetWatcherGroup(keyPrefix) != nullptr, 1);
127         return 0;
128     }
129 
TestRefreshWatcher(const std::string & keyPrefix,uint32_t watcherId)130     int TestRefreshWatcher(const std::string &keyPrefix, uint32_t watcherId)
131     {
132         WatcherManagerPtr watcherManager = GetWatcherManager();
133         WATCHER_CHECK(watcherManager != nullptr, return -1, "Failed to create manager");
134         MessageParcel data;
135         MessageParcel reply;
136         MessageOption option;
137 
138         data.WriteInterfaceToken(IWatcherManager::GetDescriptor());
139         data.WriteString(keyPrefix);
140         data.WriteUint32(watcherId);
141         watcherManager->OnRemoteRequest(
142             static_cast<uint32_t> (ParamWatcherInterfaceCode::REFRESH_WATCHER), data, reply, option);
143         EXPECT_EQ(reply.ReadInt32(), 0);
144         EXPECT_EQ(watcherManager->GetWatcherGroup(keyPrefix) != nullptr, 1);
145         return 0;
146     }
147 
TestDelWatcher(const std::string & keyPrefix,uint32_t watcherId)148     int TestDelWatcher(const std::string &keyPrefix, uint32_t watcherId)
149     {
150         WatcherManagerPtr watcherManager = GetWatcherManager();
151         WATCHER_CHECK(watcherManager != nullptr, return -1, "Failed to create manager");
152         MessageParcel data;
153         MessageParcel reply;
154         MessageOption option;
155         data.WriteInterfaceToken(IWatcherManager::GetDescriptor());
156         data.WriteString(keyPrefix);
157         data.WriteUint32(watcherId);
158         watcherManager->OnRemoteRequest(
159             static_cast<uint32_t> (ParamWatcherInterfaceCode::DEL_WATCHER), data, reply, option);
160         EXPECT_EQ(reply.ReadInt32(), 0);
161         return 0;
162     }
163 
TestProcessWatcherMessage(const std::string & name,uint32_t watcherId)164     int TestProcessWatcherMessage(const std::string &name, uint32_t watcherId)
165     {
166         WatcherManagerPtr watcherManager = GetWatcherManager();
167         WATCHER_CHECK(watcherManager != nullptr, return -1, "Failed to create manager");
168         const std::string value("test.value");
169         uint32_t msgSize = sizeof(ParamMessage) + sizeof(ParamMsgContent) + value.size();
170         msgSize = PARAM_ALIGN(msgSize); // align
171         std::vector<char> buffer(msgSize, 0);
172         ParamMessage *msg = reinterpret_cast<ParamMessage *>(buffer.data());
173         WATCHER_CHECK(msg != nullptr, return -1, "Invalid msg");
174         msg->type = MSG_NOTIFY_PARAM;
175         msg->msgSize = msgSize;
176         msg->id.watcherId = watcherId;
177         int ret = memcpy_s(msg->key, sizeof(msg->key), name.c_str(), name.size());
178         WATCHER_CHECK(ret == 0, return -1, "Failed to fill value");
179         uint32_t offset = 0;
180         ret = FillParamMsgContent(msg, &offset, PARAM_VALUE, value.c_str(), value.size());
181         WATCHER_CHECK(ret == 0, return -1, "Failed to fill value");
182         watcherManager->ProcessWatcherMessage(msg);
183         return 0;
184     }
185 
TestWatchProxy(const std::string & name,const std::string & value)186     int TestWatchProxy(const std::string &name, const std::string &value)
187     {
188         sptr<ISystemAbilityManager> systemMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
189         EXPECT_NE(systemMgr, nullptr);
190         sptr<IRemoteObject> remoteObj = systemMgr->GetSystemAbility(PARAM_WATCHER_DISTRIBUTED_SERVICE_ID);
191         EXPECT_NE(remoteObj, nullptr);
192         WatcherProxy *watcher = new WatcherProxy(remoteObj);
193         if (watcher != nullptr) {
194             watcher->OnParameterChange(name, name, value);
195             delete watcher;
196         }
197         return 0;
198     }
199 
TestWatchAgentDump(const std::string & keyPrefix)200     int TestWatchAgentDump(const std::string &keyPrefix)
201     {
202         WatcherManagerPtr watcherManager = GetWatcherManager();
203         // dump watcher
204         std::vector<std::u16string> args = {};
205         watcherManager->Dump(STDOUT_FILENO, args);
206         // dump parameter
207         args.push_back(Str8ToStr16("-h"));
208         watcherManager->Dump(STDOUT_FILENO, args);
209         args.clear();
210         args.push_back(Str8ToStr16("-k"));
211         args.push_back(Str8ToStr16(keyPrefix.c_str()));
212         watcherManager->Dump(STDOUT_FILENO, args);
213         return 0;
214     }
215 
TestWatchAgentDied(uint32_t watcherId)216     int TestWatchAgentDied(uint32_t watcherId)
217     {
218         WatcherManagerPtr watcherManager = GetWatcherManager();
219         WATCHER_CHECK(watcherManager != nullptr, return -1, "Failed to get manager");
220         auto remoteWatcher = watcherManager->GetRemoteWatcher(watcherId);
221         WATCHER_CHECK(remoteWatcher != nullptr, return -1, "Failed to get remote watcher");
222         if (watcherManager->GetDeathRecipient() != nullptr) {
223             watcherManager->GetDeathRecipient()->OnRemoteDied(remoteWatcher->GetWatcher()->AsObject());
224         }
225         EXPECT_EQ(watcherManager->GetRemoteWatcher(watcherId) == nullptr, 1);
226         return 0;
227     }
228 
TestInvalid(const std::string & keyPrefix)229     int TestInvalid(const std::string &keyPrefix)
230     {
231         WatcherManagerPtr watcherManager = GetWatcherManager();
232         WATCHER_CHECK(watcherManager != nullptr, return -1, "Failed to get manager");
233         MessageParcel data;
234         MessageParcel reply;
235         MessageOption option;
236         data.WriteInterfaceToken(IWatcherManager::GetDescriptor());
237         data.WriteString(keyPrefix);
238         data.WriteUint32(0);
239         watcherManager->OnRemoteRequest(
240             static_cast<uint32_t> (ParamWatcherInterfaceCode::REFRESH_WATCHER) + 1, data, reply, option);
241 
242         data.WriteInterfaceToken(IWatcherManager::GetDescriptor());
243         data.WriteString(keyPrefix);
244         watcherManager->OnRemoteRequest(
245             static_cast<uint32_t> (ParamWatcherInterfaceCode::REFRESH_WATCHER) + 1, data, reply, option);
246         return 0;
247     }
248 
TestStop()249     int TestStop()
250     {
251         WatcherManagerPtr watcherManager = GetWatcherManager();
252         WATCHER_CHECK(watcherManager != nullptr, return -1, "Failed to get manager");
253         watcherManager->OnStop();
254         watcherManager->Clear();
255         return 0;
256     }
257 
GetWatcherManager()258     WatcherManagerPtr GetWatcherManager()
259     {
260         static WatcherManagerPtr watcherManager_ = nullptr;
261         if (watcherManager_ == nullptr) {
262             watcherManager_ = new WatcherManager(0, true);
263             if (watcherManager_ == nullptr) {
264                 return nullptr;
265             }
266             watcherManager_->OnStart();
267         }
268         return watcherManager_;
269     }
270 };
271 
272 HWTEST_F(WatcherProxyUnitTest, Init_TestAddWatcher_001, TestSize.Level0)
273 {
274     WatcherProxyUnitTest test;
275     uint32_t watcherId = 0;
276     test.TestAddRemoteWatcher(getpid(), watcherId);
277     test.TestAddWatcher("test.permission.watcher.test1", watcherId);
278     test.TestRefreshWatcher("test.permission.watcher.test1", watcherId);
279     test.TestProcessWatcherMessage("test.permission.watcher.test1", watcherId);
280     test.TestWatchAgentDump("test.permission.watcher.test1");
281 }
282 
283 HWTEST_F(WatcherProxyUnitTest, Init_TestAddWatcher_002, TestSize.Level0)
284 {
285     WatcherProxyUnitTest test;
286     uint32_t watcherId = 0;
287     test.TestAddRemoteWatcher(getpid(), watcherId);
288     test.TestAddWatcher("test.permission.watcher.test2", watcherId);
289     test.TestAddWatcher("test.permission.watcher.test2", watcherId);
290     test.TestAddWatcher("test.permission.watcher.test2", watcherId);
291     test.TestRefreshWatcher("test.permission.watcher.test2", watcherId);
292     test.TestWatchAgentDump("test.permission.watcher.test2");
293 }
294 
295 HWTEST_F(WatcherProxyUnitTest, Init_TestAddWatcher_003, TestSize.Level0)
296 {
297     WatcherProxyUnitTest test;
298     uint32_t watcherId = 0;
299     test.TestAddRemoteWatcher(getpid(), watcherId);
300     test.TestAddWatcher("test.permission.watcher.test3", watcherId);
301     test.TestWatchAgentDump("test.permission.watcher.test3");
302 }
303 
304 HWTEST_F(WatcherProxyUnitTest, Init_TestAddWatcher_004, TestSize.Level0)
305 {
306     WatcherProxyUnitTest test;
307     uint32_t watcherId = 0;
308     test.TestAddRemoteWatcher(getpid(), watcherId);
309     SystemWriteParam("test.watcher.test4", "1101");
310     SystemWriteParam("test.watcher.test4.test", "1102");
311     test.TestAddWatcher("test.watcher.test4*", watcherId);
312     test.TestWatchAgentDump("test.watcher.test4*");
313 }
314 
315 HWTEST_F(WatcherProxyUnitTest, Init_TestAddWatcher_005, TestSize.Level0)
316 {
317     WatcherProxyUnitTest test;
318     uint32_t watcherId = 0;
319     test.TestAddRemoteWatcher(getpid(), watcherId);
320     test.TestAddWatcher("test.permission.watcher.test5", watcherId);
321     SystemWriteParam("test.permission.watcher.test5", "1101");
322     test.TestWatchAgentDump("test.permission.watcher.test5");
323 }
324 
325 HWTEST_F(WatcherProxyUnitTest, Init_TestDelWatcher_001, TestSize.Level0)
326 {
327     WatcherProxyUnitTest test;
328     uint32_t watcherId = 0;
329     test.TestAddRemoteWatcher(getpid(), watcherId);
330     test.TestAddWatcher("test.permission.watcher.testDel", watcherId);
331     test.TestDelWatcher("test.permission.watcher.testDel", watcherId);
332     test.TestDelRemoteWatcher(watcherId);
333     test.TestWatchAgentDump("test.permission.watcher.testDel");
334 }
335 
336 HWTEST_F(WatcherProxyUnitTest, Init_TestDiedWatcher_001, TestSize.Level0)
337 {
338     WatcherProxyUnitTest test;
339     uint32_t watcherId = 0;
340     test.TestAddRemoteWatcher(getpid(), watcherId);
341     test.TestAddWatcher("test.permission.watcher.testdied", watcherId);
342     test.TestDelWatcher("test.permission.watcher.testdied", watcherId);
343     test.TestWatchAgentDied(watcherId);
344     test.TestWatchAgentDump("test.permission.watcher.testdied");
345 }
346 
347 HWTEST_F(WatcherProxyUnitTest, Init_TestSendLocalChange_001, TestSize.Level0)
348 {
349     WatcherProxyUnitTest test;
350     uint32_t watcherId = 0;
351     test.TestAddRemoteWatcher(getpid(), watcherId);
352     test.TestAddWatcher("test.watcher*", watcherId);
353     test.TestAddWatcher("test.watcher.", watcherId);
354     test.TestWatchAgentDump("test.watcher.");
355 }
356 
357 HWTEST_F(WatcherProxyUnitTest, Init_TestWatchProxy_001, TestSize.Level0)
358 {
359     WatcherProxyUnitTest test;
360     test.TestWatchProxy("test.permission.watcher.test1", "watcherId");
361 }
362 
363 HWTEST_F(WatcherProxyUnitTest, Init_TestInvalid_001, TestSize.Level0)
364 {
365     WatcherProxyUnitTest test;
366     test.TestInvalid("test.permission.watcher.test1");
367 }
368 
369 HWTEST_F(WatcherProxyUnitTest, Init_TestStop_001, TestSize.Level0)
370 {
371     WatcherProxyUnitTest test;
372     uint32_t watcherId = 0;
373     test.TestAddRemoteWatcher(getpid(), watcherId);
374     test.TestAddWatcher("test.permission.watcher.stop", watcherId);
375     test.TestStop();
376 }