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
35using namespace testing::ext;
36using namespace std;
37using namespace OHOS;
38using namespace OHOS::init_param;
39
40class TestWatcher final : public Watcher {
41public:
42    TestWatcher() {}
43    ~TestWatcher() = default;
44
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
51using WatcherManagerPtr = WatcherManager *;
52class WatcherProxyUnitTest : public ::testing::Test {
53public:
54    WatcherProxyUnitTest() {}
55    virtual ~WatcherProxyUnitTest() {}
56
57    void SetUp()
58    {
59        if (GetParamSecurityLabel() != nullptr) {
60            GetParamSecurityLabel()->cred.uid = 0;
61            GetParamSecurityLabel()->cred.gid = 0;
62        }
63        SetTestPermissionResult(0);
64    }
65    void TearDown() {}
66    void TestBody() {}
67
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
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
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
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
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
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
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
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
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
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
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
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
272HWTEST_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
283HWTEST_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
295HWTEST_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
304HWTEST_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
315HWTEST_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
325HWTEST_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
336HWTEST_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
347HWTEST_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
357HWTEST_F(WatcherProxyUnitTest, Init_TestWatchProxy_001, TestSize.Level0)
358{
359    WatcherProxyUnitTest test;
360    test.TestWatchProxy("test.permission.watcher.test1", "watcherId");
361}
362
363HWTEST_F(WatcherProxyUnitTest, Init_TestInvalid_001, TestSize.Level0)
364{
365    WatcherProxyUnitTest test;
366    test.TestInvalid("test.permission.watcher.test1");
367}
368
369HWTEST_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}