• 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         watcherManager->Clear();
258         return 0;
259     }
260 
GetWatcherManager()261     WatcherManagerPtr GetWatcherManager()
262     {
263         static WatcherManagerPtr watcherManager_ = nullptr;
264         if (watcherManager_ == nullptr) {
265             watcherManager_ = new WatcherManager(0, true);
266             if (watcherManager_ == nullptr) {
267                 return nullptr;
268             }
269             watcherManager_->OnStart();
270         }
271         return watcherManager_;
272     }
273 };
274 
275 HWTEST_F(WatcherProxyUnitTest, Init_TestAddWatcher_001, TestSize.Level0)
276 {
277     WatcherProxyUnitTest test;
278     uint32_t watcherId = 0;
279     test.TestAddRemoteWatcher(getpid(), watcherId);
280     test.TestAddWatcher("test.permission.watcher.test1", watcherId);
281     test.TestRefreshWatcher("test.permission.watcher.test1", watcherId);
282     test.TestProcessWatcherMessage("test.permission.watcher.test1", watcherId);
283     test.TestWatchAgentDump("test.permission.watcher.test1");
284 }
285 
286 HWTEST_F(WatcherProxyUnitTest, Init_TestAddWatcher_002, TestSize.Level0)
287 {
288     WatcherProxyUnitTest test;
289     uint32_t watcherId = 0;
290     test.TestAddRemoteWatcher(getpid(), watcherId);
291     test.TestAddWatcher("test.permission.watcher.test2", watcherId);
292     test.TestAddWatcher("test.permission.watcher.test2", watcherId);
293     test.TestAddWatcher("test.permission.watcher.test2", watcherId);
294     test.TestRefreshWatcher("test.permission.watcher.test2", watcherId);
295     test.TestWatchAgentDump("test.permission.watcher.test2");
296 }
297 
298 HWTEST_F(WatcherProxyUnitTest, Init_TestAddWatcher_003, TestSize.Level0)
299 {
300     WatcherProxyUnitTest test;
301     uint32_t watcherId = 0;
302     test.TestAddRemoteWatcher(getpid(), watcherId);
303     test.TestAddWatcher("test.permission.watcher.test3", watcherId);
304     test.TestWatchAgentDump("test.permission.watcher.test3");
305 }
306 
307 HWTEST_F(WatcherProxyUnitTest, Init_TestAddWatcher_004, TestSize.Level0)
308 {
309     WatcherProxyUnitTest test;
310     uint32_t watcherId = 0;
311     test.TestAddRemoteWatcher(getpid(), watcherId);
312     SystemWriteParam("test.watcher.test4", "1101");
313     SystemWriteParam("test.watcher.test4.test", "1102");
314     test.TestAddWatcher("test.watcher.test4*", watcherId);
315     test.TestWatchAgentDump("test.watcher.test4*");
316 }
317 
318 HWTEST_F(WatcherProxyUnitTest, Init_TestAddWatcher_005, TestSize.Level0)
319 {
320     WatcherProxyUnitTest test;
321     uint32_t watcherId = 0;
322     test.TestAddRemoteWatcher(getpid(), watcherId);
323     test.TestAddWatcher("test.permission.watcher.test5", watcherId);
324     SystemWriteParam("test.permission.watcher.test5", "1101");
325     test.TestWatchAgentDump("test.permission.watcher.test5");
326 }
327 
328 HWTEST_F(WatcherProxyUnitTest, Init_TestDelWatcher_001, TestSize.Level0)
329 {
330     WatcherProxyUnitTest test;
331     uint32_t watcherId = 0;
332     test.TestAddRemoteWatcher(getpid(), watcherId);
333     test.TestAddWatcher("test.permission.watcher.testDel", watcherId);
334     test.TestDelWatcher("test.permission.watcher.testDel", watcherId);
335     test.TestDelRemoteWatcher(watcherId);
336     test.TestWatchAgentDump("test.permission.watcher.testDel");
337 }
338 
339 HWTEST_F(WatcherProxyUnitTest, Init_TestDiedWatcher_001, TestSize.Level0)
340 {
341     WatcherProxyUnitTest test;
342     uint32_t watcherId = 0;
343     test.TestAddRemoteWatcher(getpid(), watcherId);
344     test.TestAddWatcher("test.permission.watcher.testdied", watcherId);
345     test.TestDelWatcher("test.permission.watcher.testdied", watcherId);
346     test.TestWatchAgentDied(watcherId);
347     test.TestWatchAgentDump("test.permission.watcher.testdied");
348 }
349 
350 HWTEST_F(WatcherProxyUnitTest, Init_TestSendLocalChange_001, TestSize.Level0)
351 {
352     WatcherProxyUnitTest test;
353     uint32_t watcherId = 0;
354     test.TestAddRemoteWatcher(getpid(), watcherId);
355     test.TestAddWatcher("test.watcher*", watcherId);
356     test.TestAddWatcher("test.watcher.", watcherId);
357     test.TestWatchAgentDump("test.watcher.");
358 }
359 
360 HWTEST_F(WatcherProxyUnitTest, Init_TestWatchProxy_001, TestSize.Level0)
361 {
362     WatcherProxyUnitTest test;
363     test.TestWatchProxy("test.permission.watcher.test1", "watcherId");
364 }
365 
366 HWTEST_F(WatcherProxyUnitTest, Init_TestInvalid_001, TestSize.Level0)
367 {
368     WatcherProxyUnitTest test;
369     test.TestInvalid("test.permission.watcher.test1");
370 }
371 
372 HWTEST_F(WatcherProxyUnitTest, Init_TestStop_001, TestSize.Level0)
373 {
374     WatcherProxyUnitTest test;
375     uint32_t watcherId = 0;
376     fdsan_set_error_level(FDSAN_ERROR_LEVEL_DISABLED);
377 
378     test.TestAddRemoteWatcher(getpid(), watcherId);
379     test.TestAddWatcher("test.permission.watcher.stop", watcherId);
380     test.TestStop();
381 }