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