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 "init_param.h"
19#include "iservice_registry.h"
20#include "iwatcher.h"
21#include "iwatcher_manager.h"
22#include "message_parcel.h"
23#include "parameter.h"
24#include "param_manager.h"
25#include "param_stub.h"
26#include "param_utils.h"
27#include "system_ability_definition.h"
28#include "watcher.h"
29#include "watcher_manager_kits.h"
30#include "watcher_manager_proxy.h"
31#include "service_watcher.h"
32
33using namespace testing::ext;
34using namespace std;
35using namespace OHOS;
36using namespace OHOS::init_param;
37
38int g_callbackCount = 0;
39static void TestParameterChange(const char *key, const char *value, void *context)
40{
41    printf("TestParameterChange key:%s %s \n", key, value);
42    g_callbackCount++;
43}
44
45static void TestWatcherCallBack(const char *key, const ServiceInfo *status)
46{
47    printf("TestWatcherCallBack key:%s %d", key, status->status);
48}
49
50class WatcherAgentUnitTest : public ::testing::Test {
51public:
52    WatcherAgentUnitTest() {}
53    virtual ~WatcherAgentUnitTest() {}
54
55    void SetUp()
56    {
57        if (GetParamSecurityLabel() != nullptr) {
58            GetParamSecurityLabel()->cred.uid = 1000;  // 1000 test uid
59            GetParamSecurityLabel()->cred.gid = 1000;  // 1000 test gid
60        }
61        SetTestPermissionResult(0);
62    }
63    void TearDown() {}
64    void TestBody() {}
65
66    int TestAddWatcher0(size_t index)
67    {
68        int ret = 0;
69        // has beed deleted
70        ret = RemoveParameterWatcher("test.permission.watcher.test1",
71            TestParameterChange, reinterpret_cast<void *>(index));
72        EXPECT_NE(ret, 0);
73
74        // delete all
75        ret = SystemWatchParameter("test.permission.watcher.test1",
76            TestParameterChange, reinterpret_cast<void *>(index));
77        EXPECT_EQ(ret, 0);
78        index++;
79        ret = SystemWatchParameter("test.permission.watcher.test1",
80            TestParameterChange, reinterpret_cast<void *>(index));
81        EXPECT_EQ(ret, 0);
82        ret = RemoveParameterWatcher("test.permission.watcher.test1", nullptr, nullptr);
83        EXPECT_EQ(ret, 0);
84        // 非法
85        ret = SystemWatchParameter("test.permission.watcher.tes^^^^t1*", TestParameterChange, nullptr);
86        EXPECT_EQ(ret, PARAM_CODE_INVALID_NAME);
87        ret = SystemWatchParameter("test.permission.read.test1*", TestParameterChange, nullptr);
88        EXPECT_EQ(ret, DAC_RESULT_FORBIDED);
89        return ret;
90    }
91    int TestAddWatcher()
92    {
93        size_t index = 1;
94        int ret = SystemWatchParameter("test.permission.watcher.test1",
95            TestParameterChange, reinterpret_cast<void *>(index));
96        EXPECT_EQ(ret, 0);
97        ret = SystemWatchParameter("test.permission.watcher.test1*",
98            TestParameterChange, reinterpret_cast<void *>(index));
99        EXPECT_EQ(ret, 0);
100        // repeat add, return fail
101        ret = SystemWatchParameter("test.permission.watcher.test1",
102            TestParameterChange, reinterpret_cast<void *>(index));
103        EXPECT_NE(ret, 0);
104        index++;
105        ret = SystemWatchParameter("test.permission.watcher.test1",
106            TestParameterChange, reinterpret_cast<void *>(index));
107        EXPECT_EQ(ret, 0);
108        index++;
109        ret = SystemWatchParameter("test.permission.watcher.test1",
110            TestParameterChange, reinterpret_cast<void *>(index));
111        EXPECT_EQ(ret, 0);
112
113        // delete
114        ret = RemoveParameterWatcher("test.permission.watcher.test1",
115            TestParameterChange, reinterpret_cast<void *>(index));
116        EXPECT_EQ(ret, 0);
117        ret = RemoveParameterWatcher("test.permission.watcher.test1",
118            TestParameterChange, reinterpret_cast<void *>(index));
119        EXPECT_EQ(ret, 0);
120        index--;
121        ret = RemoveParameterWatcher("test.permission.watcher.test1",
122            TestParameterChange, reinterpret_cast<void *>(index));
123        EXPECT_EQ(ret, 0);
124        index--;
125        ret = RemoveParameterWatcher("test.permission.watcher.test1",
126            TestParameterChange, reinterpret_cast<void *>(index));
127        EXPECT_EQ(ret, 0);
128        return TestAddWatcher0(index);
129    }
130
131    int TestDelWatcher()
132    {
133        size_t index = 1;
134        int ret = SystemWatchParameter("test.permission.watcher.test3.1",
135            TestParameterChange, reinterpret_cast<void *>(index));
136        EXPECT_EQ(ret, 0);
137        ret = SystemWatchParameter("test.permission.watcher.test3.1*",
138            TestParameterChange, reinterpret_cast<void *>(index));
139        EXPECT_EQ(ret, 0);
140        ret = SystemWatchParameter("test.permission.watcher.test3.2",
141            TestParameterChange, reinterpret_cast<void *>(index));
142        EXPECT_EQ(ret, 0);
143        ret = SystemWatchParameter("test.permission.watcher.test3.2", TestParameterChange,
144            reinterpret_cast<void *>(index));
145        EXPECT_EQ(ret, PARAM_WATCHER_CALLBACK_EXIST);
146        ret = SystemWatchParameter("test.permission.watcher.test3.1", nullptr, nullptr);
147        EXPECT_EQ(ret, 0);
148        ret = SystemWatchParameter("test.permission.watcher.test3.1*", nullptr, nullptr);
149        EXPECT_EQ(ret, 0);
150        ret = SystemWatchParameter("test.permission.watcher.test3.2", nullptr, nullptr);
151        EXPECT_EQ(ret, 0);
152
153        // 非法
154        ret = SystemWatchParameter("test.permission.watcher.tes^^^^t1*", nullptr, nullptr);
155        EXPECT_EQ(ret, PARAM_CODE_INVALID_NAME);
156        ret = SystemWatchParameter("test.permission.read.test1*", nullptr, nullptr);
157        EXPECT_EQ(ret, DAC_RESULT_FORBIDED);
158        return 0;
159    }
160
161    int TestRecvMessage(const std::string &name)
162    {
163        MessageParcel data;
164        MessageParcel reply;
165        MessageOption option;
166        data.WriteInterfaceToken(IWatcher::GetDescriptor());
167        data.WriteString(name);
168        data.WriteString(name);
169        data.WriteString("watcherId");
170        g_callbackCount = 0;
171        int ret = SystemWatchParameter(name.c_str(), TestParameterChange, nullptr);
172        EXPECT_EQ(ret, 0);
173        WatcherManagerKits &instance = OHOS::init_param::WatcherManagerKits::GetInstance();
174        if (instance.remoteWatcher_ != nullptr) {
175            instance.remoteWatcher_->OnRemoteRequest(IWatcher::PARAM_CHANGE, data, reply, option);
176            instance.remoteWatcher_->OnRemoteRequest(IWatcher::PARAM_CHANGE + 1, data, reply, option);
177            instance.remoteWatcher_->OnParameterChange(name.c_str(), "testname", "testvalue");
178            EXPECT_EQ(g_callbackCount, 2); // 2 is callback Count
179            instance.remoteWatcher_->OnParameterChange(name.c_str(), "testname.2", "testvalue");
180            EXPECT_EQ(g_callbackCount, 3); // 3 is callback Count
181            instance.remoteWatcher_->OnParameterChange(name.c_str(), "testname.2", "testvalue");
182            EXPECT_EQ(g_callbackCount, 3); // 3 is callback Count
183
184            // prefix not exit
185            instance.remoteWatcher_->OnParameterChange("44444444444444444444", "testname.2", "testvalue");
186        }
187        EXPECT_EQ(g_callbackCount, 3); // 3 is callback Count
188        return 0;
189    }
190
191    int TestResetService()
192    {
193        sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
194        WATCHER_CHECK(samgr != nullptr, return -1, "Get samgr failed");
195        sptr<IRemoteObject> object = samgr->GetSystemAbility(PARAM_WATCHER_DISTRIBUTED_SERVICE_ID);
196        WATCHER_CHECK(object != nullptr, return -1, "Get watcher manager object from samgr failed");
197        OHOS::init_param::WatcherManagerKits &instance = OHOS::init_param::WatcherManagerKits::GetInstance();
198        if (instance.GetDeathRecipient() != nullptr) {
199            instance.GetDeathRecipient()->OnRemoteDied(object);
200        }
201        return 0;
202    }
203
204    void TestWatcherProxy()
205    {
206        sptr<WatcherManagerProxy> watcherManager = new(std::nothrow) WatcherManagerProxy(nullptr);
207        ASSERT_NE(watcherManager, nullptr);
208
209        WatcherManagerKits &instance = OHOS::init_param::WatcherManagerKits::GetInstance();
210        sptr<Watcher> remoteWatcher = new OHOS::init_param::WatcherManagerKits::RemoteWatcher(&instance);
211        ASSERT_NE(remoteWatcher, nullptr);
212
213        MessageParcel data;
214        MessageParcel reply;
215        MessageOption option;
216        data.WriteInterfaceToken(IWatcher::GetDescriptor());
217        data.WriteString("name");
218        data.WriteString("name");
219        data.WriteString("watcherId");
220        remoteWatcher->OnRemoteRequest(IWatcher::PARAM_CHANGE, data, reply, option);
221
222        // invalid parameter
223        data.WriteInterfaceToken(IWatcher::GetDescriptor());
224        data.WriteString("name");
225        data.WriteString("watcherId");
226        remoteWatcher->OnRemoteRequest(IWatcher::PARAM_CHANGE, data, reply, option);
227
228        data.WriteInterfaceToken(IWatcher::GetDescriptor());
229        data.WriteString("name");
230        remoteWatcher->OnRemoteRequest(IWatcher::PARAM_CHANGE, data, reply, option);
231
232        data.WriteInterfaceToken(IWatcher::GetDescriptor());
233        remoteWatcher->OnRemoteRequest(IWatcher::PARAM_CHANGE, data, reply, option);
234
235        data.WriteInterfaceToken(IWatcher::GetDescriptor());
236        data.WriteString("name");
237        data.WriteString("name");
238        data.WriteString("watcherId");
239        remoteWatcher->OnRemoteRequest(IWatcher::PARAM_CHANGE + 1, data, reply, option);
240        remoteWatcher->OnRemoteRequest(IWatcher::PARAM_CHANGE + 1, data, reply, option);
241
242        uint32_t watcherId = watcherManager->AddRemoteWatcher(1000, remoteWatcher);
243        // add watcher
244        int ret = watcherManager->AddWatcher("test.watcher.proxy", watcherId);
245        ASSERT_EQ(ret, 0);
246        ret = watcherManager->DelWatcher("test.watcher.proxy", watcherId);
247        ASSERT_EQ(ret, 0);
248        ret = watcherManager->RefreshWatcher("test.watcher.proxy", watcherId);
249        ASSERT_EQ(ret, 0);
250        watcherManager->DelRemoteWatcher(watcherId);
251    }
252};
253
254HWTEST_F(WatcherAgentUnitTest, Init_TestAddWatcher_001, TestSize.Level0)
255{
256    WatcherAgentUnitTest test;
257    test.TestAddWatcher();
258}
259
260HWTEST_F(WatcherAgentUnitTest, Init_TestRecvMessage_001, TestSize.Level0)
261{
262    WatcherAgentUnitTest test;
263    test.TestRecvMessage("test.permission.watcher.agent.test1");
264}
265
266HWTEST_F(WatcherAgentUnitTest, Init_TestDelWatcher_001, TestSize.Level0)
267{
268    WatcherAgentUnitTest test;
269    test.TestDelWatcher();
270}
271
272HWTEST_F(WatcherAgentUnitTest, Init_TestResetService_001, TestSize.Level0)
273{
274    WatcherAgentUnitTest test;
275    test.TestResetService();
276}
277
278HWTEST_F(WatcherAgentUnitTest, Init_TestWatcherService_001, TestSize.Level0)
279{
280    const char *errstr = "111111111111111111111111111111111111111111111111111111111111111111111111111111111111";
281    ServiceWatchForStatus("param_watcher", TestWatcherCallBack);
282    ServiceWaitForStatus("param_watcher", SERVICE_STARTED, 1);
283    EXPECT_NE(ServiceWatchForStatus(errstr, TestWatcherCallBack), 0);
284    EXPECT_NE(ServiceWatchForStatus(nullptr, TestWatcherCallBack), 0);
285    WatchParameter("testParam", nullptr, nullptr);
286    WatchParameter(nullptr, nullptr, nullptr);
287}
288
289HWTEST_F(WatcherAgentUnitTest, Init_TestInvalidWatcher_001, TestSize.Level0)
290{
291    int ret = SystemWatchParameter(nullptr, TestParameterChange, nullptr);
292    ASSERT_NE(ret, 0);
293    ret = RemoveParameterWatcher(nullptr, nullptr, nullptr);
294    ASSERT_NE(ret, 0);
295}
296
297HWTEST_F(WatcherAgentUnitTest, Init_TestWatcherProxy_001, TestSize.Level0)
298{
299    WatcherAgentUnitTest test;
300    test.TestWatcherProxy();
301}
302