• 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     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() {}
TearDown()58     void TearDown() {}
TestBody()59     void TestBody() {}
60 
TestAddRemoteWatcher(uint32_t agentId,uint32_t & watcherId)61     int TestAddRemoteWatcher(uint32_t agentId, uint32_t &watcherId)
62     {
63         WatcherManagerPtr watcherManager = GetWatcherManager();
64         WATCHER_CHECK(watcherManager != nullptr, return -1, "Failed to create manager");
65         MessageParcel data;
66         MessageParcel reply;
67         MessageOption option;
68 
69         data.WriteInterfaceToken(IWatcherManager::GetDescriptor());
70         sptr<IWatcher> watcher = new TestWatcher();
71         bool ret = data.WriteRemoteObject(watcher->AsObject());
72         WATCHER_CHECK(ret, return 0, "Can not get remote");
73         data.WriteUint32(agentId);
74         watcherManager->OnRemoteRequest(IWatcherManager::ADD_REMOTE_AGENT, data, reply, option);
75         watcherId = reply.ReadUint32();
76         EXPECT_NE(watcherId, 0);
77 
78         auto remoteWatcher = watcherManager->GetRemoteWatcher(watcherId);
79         if (remoteWatcher != nullptr) {
80             EXPECT_EQ(remoteWatcher->GetAgentId(), agentId);
81         } else {
82             EXPECT_EQ(0, agentId);
83         }
84         return 0;
85     }
86 
TestDelRemoteWatcher(uint32_t watcherId)87     int TestDelRemoteWatcher(uint32_t watcherId)
88     {
89         WatcherManagerPtr watcherManager = GetWatcherManager();
90         WATCHER_CHECK(watcherManager != nullptr, return -1, "Failed to create manager");
91         MessageParcel data;
92         MessageParcel reply;
93         MessageOption option;
94 
95         data.WriteInterfaceToken(IWatcherManager::GetDescriptor());
96         data.WriteUint32(watcherId);
97         watcherManager->OnRemoteRequest(IWatcherManager::DEL_REMOTE_AGENT, data, reply, option);
98         EXPECT_EQ(reply.ReadInt32(), 0);
99         EXPECT_EQ(watcherManager->GetRemoteWatcher(watcherId) == nullptr, 1);
100         return 0;
101     }
102 
TestAddWatcher(const std::string & keyPrefix,uint32_t watcherId)103     int TestAddWatcher(const std::string &keyPrefix, uint32_t watcherId)
104     {
105         WatcherManagerPtr watcherManager = GetWatcherManager();
106         WATCHER_CHECK(watcherManager != nullptr, return -1, "Failed to create manager");
107         MessageParcel data;
108         MessageParcel reply;
109         MessageOption option;
110 
111         data.WriteInterfaceToken(IWatcherManager::GetDescriptor());
112         data.WriteString(keyPrefix);
113         data.WriteUint32(watcherId);
114         watcherManager->OnRemoteRequest(IWatcherManager::ADD_WATCHER, data, reply, option);
115         int ret = reply.ReadInt32();
116         EXPECT_EQ(ret, 0);
117         EXPECT_EQ(watcherManager->GetWatcherGroup(keyPrefix) != nullptr, 1);
118         return 0;
119     }
120 
TestDelWatcher(const std::string & keyPrefix,uint32_t watcherId)121     int TestDelWatcher(const std::string &keyPrefix, uint32_t watcherId)
122     {
123         WatcherManagerPtr watcherManager = GetWatcherManager();
124         WATCHER_CHECK(watcherManager != nullptr, return -1, "Failed to create manager");
125         MessageParcel data;
126         MessageParcel reply;
127         MessageOption option;
128         data.WriteInterfaceToken(IWatcherManager::GetDescriptor());
129         data.WriteString(keyPrefix);
130         data.WriteUint32(watcherId);
131         watcherManager->OnRemoteRequest(IWatcherManager::DEL_WATCHER, data, reply, option);
132         EXPECT_EQ(reply.ReadInt32(), 0);
133         return 0;
134     }
135 
TestProcessWatcherMessage(const std::string & name,uint32_t watcherId)136     int TestProcessWatcherMessage(const std::string &name, uint32_t watcherId)
137     {
138         WatcherManagerPtr watcherManager = GetWatcherManager();
139         WATCHER_CHECK(watcherManager != nullptr, return -1, "Failed to create manager");
140         const std::string value("test.value");
141         uint32_t msgSize = sizeof(ParamMessage) + sizeof(ParamMsgContent) + value.size();
142         msgSize = PARAM_ALIGN(msgSize); // align
143         std::vector<char> buffer(msgSize, 0);
144         ParamMessage *msg = reinterpret_cast<ParamMessage *>(buffer.data());
145         WATCHER_CHECK(msg != nullptr, return -1, "Invalid msg");
146         msg->type = MSG_NOTIFY_PARAM;
147         msg->msgSize = msgSize;
148         msg->id.watcherId = watcherId;
149         int ret = memcpy_s(msg->key, sizeof(msg->key), name.c_str(), name.size());
150         WATCHER_CHECK(ret == 0, return -1, "Failed to fill value");
151         uint32_t offset = 0;
152         ret = FillParamMsgContent(msg, &offset, PARAM_VALUE, value.c_str(), value.size());
153         WATCHER_CHECK(ret == 0, return -1, "Failed to fill value");
154         watcherManager->ProcessWatcherMessage(msg);
155         return 0;
156     }
157 
TestWatchProxy(const std::string & name,const std::string & value)158     int TestWatchProxy(const std::string &name, const std::string &value)
159     {
160         sptr<ISystemAbilityManager> systemMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
161         EXPECT_NE(systemMgr, nullptr);
162         sptr<IRemoteObject> remoteObj = systemMgr->GetSystemAbility(PARAM_WATCHER_DISTRIBUTED_SERVICE_ID);
163         EXPECT_NE(remoteObj, nullptr);
164         WatcherProxy *watcher = new WatcherProxy(remoteObj);
165         if (watcher != nullptr) {
166             watcher->OnParameterChange(name, name, value);
167             delete watcher;
168         }
169         return 0;
170     }
171 
TestWatchAgentDump(const std::string & keyPrefix)172     int TestWatchAgentDump(const std::string &keyPrefix)
173     {
174         WatcherManagerPtr watcherManager = GetWatcherManager();
175         // dump watcher
176         std::vector<std::u16string> args = {};
177         watcherManager->Dump(STDOUT_FILENO, args);
178         // dump parameter
179         args.push_back(Str8ToStr16("-h"));
180         watcherManager->Dump(STDOUT_FILENO, args);
181         args.clear();
182         args.push_back(Str8ToStr16("-k"));
183         args.push_back(Str8ToStr16(keyPrefix.c_str()));
184         watcherManager->Dump(STDOUT_FILENO, args);
185         return 0;
186     }
187 
TestWatchAgentDied(uint32_t watcherId)188     int TestWatchAgentDied(uint32_t watcherId)
189     {
190         WatcherManagerPtr watcherManager = GetWatcherManager();
191         WATCHER_CHECK(watcherManager != nullptr, return -1, "Failed to get manager");
192         auto remoteWatcher = watcherManager->GetRemoteWatcher(watcherId);
193         WATCHER_CHECK(remoteWatcher != nullptr, return -1, "Failed to get remote watcher");
194         if (watcherManager->GetDeathRecipient() != nullptr) {
195             watcherManager->GetDeathRecipient()->OnRemoteDied(remoteWatcher->GetWatcher()->AsObject());
196         }
197         EXPECT_EQ(watcherManager->GetRemoteWatcher(watcherId) == nullptr, 1);
198         return 0;
199     }
200 
TestInvalid(const std::string & keyPrefix)201     int TestInvalid(const std::string &keyPrefix)
202     {
203         WatcherManagerPtr watcherManager = GetWatcherManager();
204         WATCHER_CHECK(watcherManager != nullptr, return -1, "Failed to get manager");
205         MessageParcel data;
206         MessageParcel reply;
207         MessageOption option;
208         data.WriteString(keyPrefix);
209         watcherManager->OnRemoteRequest(IWatcherManager::REFRESH_WATCHER + 1, data, reply, option);
210 
211         data.WriteInterfaceToken(IWatcherManager::GetDescriptor());
212         data.WriteString(keyPrefix);
213         watcherManager->OnRemoteRequest(IWatcherManager::REFRESH_WATCHER + 1, data, reply, option);
214         return 0;
215     }
216 
TestStop()217     int TestStop()
218     {
219         WatcherManagerPtr watcherManager = GetWatcherManager();
220         WATCHER_CHECK(watcherManager != nullptr, return -1, "Failed to get manager");
221         watcherManager->OnStop();
222         return 0;
223     }
224 
GetWatcherManager()225     WatcherManagerPtr GetWatcherManager()
226     {
227         static WatcherManagerPtr watcherManager = nullptr;
228         if (watcherManager == nullptr) {
229             watcherManager = new WatcherManager(0, true);
230             if (watcherManager == nullptr) {
231                 return nullptr;
232             }
233             watcherManager->OnStart();
234         }
235         return watcherManager;
236     }
237 };
238 
239 HWTEST_F(WatcherProxyUnitTest, TestAddWatcher, TestSize.Level0)
240 {
241     WatcherProxyUnitTest test;
242     uint32_t watcherId = 0;
243     test.TestAddRemoteWatcher(1000, watcherId); // 1000 test agent
244     test.TestAddWatcher("test.permission.watcher.test1", watcherId);
245     test.TestProcessWatcherMessage("test.permission.watcher.test1", watcherId);
246     test.TestWatchAgentDump("test.permission.watcher.test1");
247 }
248 
249 HWTEST_F(WatcherProxyUnitTest, TestAddWatcher2, TestSize.Level0)
250 {
251     WatcherProxyUnitTest test;
252     uint32_t watcherId = 0;
253     test.TestAddRemoteWatcher(1001, watcherId); // 1001 test agent
254     test.TestAddWatcher("test.permission.watcher.test2", watcherId);
255     test.TestAddWatcher("test.permission.watcher.test2", watcherId);
256     test.TestAddWatcher("test.permission.watcher.test2", watcherId);
257     test.TestWatchAgentDump("test.permission.watcher.test2");
258 }
259 
260 HWTEST_F(WatcherProxyUnitTest, TestAddWatcher3, TestSize.Level0)
261 {
262     WatcherProxyUnitTest test;
263     uint32_t watcherId = 0;
264     test.TestAddRemoteWatcher(1003, watcherId); // 1003 test agent
265     test.TestAddWatcher("test.permission.watcher.test3", watcherId);
266     test.TestWatchAgentDump("test.permission.watcher.test3");
267 }
268 
269 HWTEST_F(WatcherProxyUnitTest, TestAddWatcher4, TestSize.Level0)
270 {
271     WatcherProxyUnitTest test;
272     uint32_t watcherId = 0;
273     test.TestAddRemoteWatcher(1004, watcherId); // 1004 test agent
274     SystemSetParameter("test.watcher.test4", "1101");
275     SystemSetParameter("test.watcher.test4.test", "1102");
276     test.TestAddWatcher("test.watcher.test4*", watcherId);
277     test.TestWatchAgentDump("test.watcher.test4*");
278 }
279 
280 HWTEST_F(WatcherProxyUnitTest, TestAddWatcher5, TestSize.Level0)
281 {
282     WatcherProxyUnitTest test;
283     uint32_t watcherId = 0;
284     test.TestAddRemoteWatcher(1005, watcherId); // 1005 test agent
285     test.TestAddWatcher("test.permission.watcher.test5", watcherId);
286     SystemSetParameter("test.permission.watcher.test5", "1101");
287     test.TestWatchAgentDump("test.permission.watcher.test5");
288 }
289 
290 HWTEST_F(WatcherProxyUnitTest, TestDelWatcher, TestSize.Level0)
291 {
292     WatcherProxyUnitTest test;
293     uint32_t watcherId = 0;
294     test.TestAddRemoteWatcher(1006, watcherId); // 1005 test agent
295     test.TestAddWatcher("test.permission.watcher.testDel", watcherId);
296     test.TestDelWatcher("test.permission.watcher.testDel", watcherId);
297     test.TestDelRemoteWatcher(watcherId);
298     test.TestWatchAgentDump("test.permission.watcher.testDel");
299 }
300 
301 HWTEST_F(WatcherProxyUnitTest, TestDiedWatcher, TestSize.Level0)
302 {
303     WatcherProxyUnitTest test;
304     uint32_t watcherId = 0;
305     test.TestAddRemoteWatcher(1006, watcherId); // 1005 test agent
306     test.TestAddWatcher("test.permission.watcher.testdied", watcherId);
307     test.TestDelWatcher("test.permission.watcher.testdied", watcherId);
308     test.TestWatchAgentDied(watcherId);
309     test.TestWatchAgentDump("test.permission.watcher.testdied");
310 }
311 
312 HWTEST_F(WatcherProxyUnitTest, TestWatchProxy, TestSize.Level0)
313 {
314     WatcherProxyUnitTest test;
315     test.TestWatchProxy("test.permission.watcher.test1", "watcherId");
316 }
317 
318 HWTEST_F(WatcherProxyUnitTest, TestInvalid, TestSize.Level0)
319 {
320     WatcherProxyUnitTest test;
321     test.TestInvalid("test.permission.watcher.test1");
322 }
323 
324 HWTEST_F(WatcherProxyUnitTest, TestStop, TestSize.Level0)
325 {
326     WatcherProxyUnitTest test;
327     test.TestStop();
328 }