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