• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2025 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 #define LOG_TAG "KVDBServiceStubTest "
16 
17 #include "kvdb_service_stub.h"
18 #include "kvdb_service_impl.h"
19 #include "gtest/gtest.h"
20 #include "ipc_skeleton.h"
21 #include "kv_types_util.h"
22 #include "log_print.h"
23 #include "types.h"
24 #include "device_matrix.h"
25 #include "bootstrap.h"
26 #include "itypes_util.h"
27 
28 using namespace OHOS;
29 using namespace testing;
30 using namespace testing::ext;
31 using namespace OHOS::DistributedData;
32 using KVDBServiceStub = OHOS::DistributedKv::KVDBServiceStub;
33 using StoreId = OHOS::DistributedKv::StoreId;
34 using AppId = OHOS::DistributedKv::AppId;
35 using Options = OHOS::DistributedKv::Options;
36 const std::u16string INTERFACE_TOKEN = u"OHOS.DistributedKv.IKvStoreDataService";
37 static const StoreId STOREID = { "kvdb_test_storeid" };
38 static const AppId APPID = { "kvdb_test_appid" };
39 static const std::string HAPNAME = "testHap";
40 static const std::string INVALID_HAPNAME = "./testHap";
41 static const StoreId INVALID_STOREID = { "./kvdb_test_storeid" };
42 static const AppId INVALID_APPID = { "\\kvdb_test_appid" };
43 
44 namespace OHOS::Test {
45 namespace DistributedDataTest {
46 class KVDBServiceStubTest : public testing::Test {
47 public:
SetUpTestCase(void)48     static void SetUpTestCase(void) {};
TearDownTestCase(void)49     static void TearDownTestCase(void) {};
SetUp()50     void SetUp() {};
TearDown()51     void TearDown() {};
52 };
53 std::shared_ptr<DistributedKv::KVDBServiceImpl> kvdbServiceImpl = std::make_shared<DistributedKv::KVDBServiceImpl>();
54 std::shared_ptr<KVDBServiceStub> kvdbServiceStub = kvdbServiceImpl;
55 
56 /**
57  * @tc.name: OnRemoteRequest_Test_001
58  * @tc.desc: Test OnRemoteRequest
59  * @tc.type: FUNC
60  * @tc.require:
61  */
62 HWTEST_F(KVDBServiceStubTest, OnRemoteRequest, TestSize.Level1)
63 {
64     MessageParcel data;
65     MessageParcel reply;
66     uint32_t code = 0;
67     auto result = kvdbServiceStub->OnRemoteRequest(code, data, reply);
68     EXPECT_EQ(result, -1);
69 }
70 
71 /**
72  * @tc.name: OnRemoteRequest_Test_001
73  * @tc.desc: Test OnRemoteRequest
74  * @tc.type: FUNC
75  * @tc.require:
76  */
77 HWTEST_F(KVDBServiceStubTest, OnRemoteRequest001, TestSize.Level1)
78 {
79     MessageParcel data;
80     MessageParcel reply;
81     uint32_t code = static_cast<uint32_t>(DistributedKv::KVDBServiceInterfaceCode::TRANS_HEAD) - 1;
82     auto result = kvdbServiceStub->OnRemoteRequest(code, data, reply);
83     EXPECT_EQ(result, -1);
84 
85     // Test code greater than TRANS_BUTT
86     code = static_cast<uint32_t>(DistributedKv::KVDBServiceInterfaceCode::TRANS_BUTT);
87     result = kvdbServiceStub->OnRemoteRequest(code, data, reply);
88     EXPECT_EQ(result, -1);
89 }
90 
91 /**
92  * @tc.name: GetStoreInfo
93  * @tc.desc: Test GetStoreInfo
94  * @tc.type: FUNC
95  * @tc.require:
96  */
97 HWTEST_F(KVDBServiceStubTest, GetStoreInfo, TestSize.Level1)
98 {
99     MessageParcel data;
100     auto [status, info] = kvdbServiceStub->GetStoreInfo(0, data);
101     EXPECT_EQ(status, IPC_STUB_INVALID_DATA_ERR);
102 }
103 
104 /**
105  * @tc.name: GetStoreInfo
106  * @tc.desc: Test GetStoreInfo
107  * @tc.type: FUNC
108  * @tc.require:
109  */
110 HWTEST_F(KVDBServiceStubTest, GetStoreInfo001, TestSize.Level1)
111 {
112     MessageParcel data;
113     AppId appId = {"test_app"};
114     StoreId storeId = {"test_store"};
115     auto [status, info] = kvdbServiceStub->GetStoreInfo(0, data);
116     EXPECT_EQ(status, IPC_STUB_INVALID_DATA_ERR);
117     EXPECT_EQ(info.bundleName, "");
118     EXPECT_EQ(info.storeId, "");
119 }
120 
121 /**
122  * @tc.name: CheckPermission
123  * @tc.desc: Test CheckPermission
124  * @tc.type: FUNC
125  * @tc.require:
126  */
127 HWTEST_F(KVDBServiceStubTest, CheckPermission, TestSize.Level1)
128 {
129     KVDBServiceStub::StoreInfo info;
130     info.bundleName = "test_bundleName";
131     info.storeId = "test_storeId";
132     uint32_t code = static_cast<uint32_t>(DistributedKv::KVDBServiceInterfaceCode::TRANS_PUT_SWITCH);
133     auto status = kvdbServiceStub->CheckPermission(code, info);
134     EXPECT_FALSE(status);
135 
136     code = static_cast<uint32_t>(DistributedKv::KVDBServiceInterfaceCode::TRANS_UNSUBSCRIBE_SWITCH_DATA);
137     status = kvdbServiceStub->CheckPermission(code, info);
138     EXPECT_FALSE(status);
139 }
140 
141 /**
142  * @tc.name: CheckPermission
143  * @tc.desc: Test CheckPermission
144  * @tc.type: FUNC
145  * @tc.require:
146  */
147 HWTEST_F(KVDBServiceStubTest, CheckPermission001, TestSize.Level1)
148 {
149     KVDBServiceStub::StoreInfo info;
150     info.bundleName = "validApp";
151     info.storeId = "validStore";
152     EXPECT_FALSE(kvdbServiceStub->CheckPermission(0, info));
153 }
154 
155 
156 /**
157  * @tc.name: OnBeforeCreate001
158  * @tc.desc: Test OnBeforeCreate
159  * @tc.type: FUNC
160  * @tc.require:
161  */
162 HWTEST_F(KVDBServiceStubTest, OnBeforeCreate001, TestSize.Level1)
163 {
164     MessageParcel data;
165     data.WriteInterfaceToken(INTERFACE_TOKEN);
166     MessageParcel reply;
167     Options options;
168     options.hapName = HAPNAME;
169     ITypesUtil::Marshal(data, options);
170     auto status = kvdbServiceStub->OnBeforeCreate(APPID, STOREID, data, reply);
171     EXPECT_EQ(status, IPC_STUB_INVALID_DATA_ERR);
172 }
173 
174 /**
175  * @tc.name: OnBeforeCreate002
176  * @tc.desc: Test OnBeforeCreate
177  * @tc.type: FUNC
178  * @tc.require:
179  */
180 HWTEST_F(KVDBServiceStubTest, OnBeforeCreate002, TestSize.Level1)
181 {
182     MessageParcel data;
183     data.WriteInterfaceToken(INTERFACE_TOKEN);
184     MessageParcel reply;
185     Options options;
186     options.hapName = HAPNAME;
187     ITypesUtil::Marshal(data, options);
188     auto status = kvdbServiceStub->OnBeforeCreate(INVALID_APPID, INVALID_STOREID, data, reply);
189     EXPECT_EQ(status, IPC_STUB_INVALID_DATA_ERR);
190 }
191 
192 /**
193  * @tc.name: OnBeforeCreate003
194  * @tc.desc: Test OnBeforeCreate
195  * @tc.type: FUNC
196  * @tc.require:
197  */
198 HWTEST_F(KVDBServiceStubTest, OnBeforeCreate003, TestSize.Level1)
199 {
200     MessageParcel data;
201     data.WriteInterfaceToken(INTERFACE_TOKEN);
202     MessageParcel reply;
203     Options options;
204     options.hapName = INVALID_HAPNAME;
205     ITypesUtil::Marshal(data, options);
206     auto status = kvdbServiceStub->OnBeforeCreate(APPID, STOREID, data, reply);
207     EXPECT_EQ(status, IPC_STUB_INVALID_DATA_ERR);
208 }
209 
210 /**
211  * @tc.name: OnAfterCreate001
212  * @tc.desc: Test OnAfterCreate
213  * @tc.type: FUNC
214  * @tc.require:
215  */
216 HWTEST_F(KVDBServiceStubTest, OnAfterCreate001, TestSize.Level1)
217 {
218     MessageParcel data;
219     data.WriteInterfaceToken(INTERFACE_TOKEN);
220     MessageParcel reply;
221     Options options;
222     options.hapName = HAPNAME;
223     ITypesUtil::Marshal(data, options);
224     auto status = kvdbServiceStub->OnAfterCreate(APPID, STOREID, data, reply);
225     EXPECT_EQ(status, IPC_STUB_INVALID_DATA_ERR);
226 }
227 
228 /**
229  * @tc.name: OnAfterCreate002
230  * @tc.desc: Test OnAfterCreate
231  * @tc.type: FUNC
232  * @tc.require:
233  */
234 HWTEST_F(KVDBServiceStubTest, OnAfterCreate002, TestSize.Level1)
235 {
236     MessageParcel data;
237     data.WriteInterfaceToken(INTERFACE_TOKEN);
238     MessageParcel reply;
239     Options options;
240     options.hapName = HAPNAME;
241     ITypesUtil::Marshal(data, options);
242     auto status = kvdbServiceStub->OnAfterCreate(INVALID_APPID, INVALID_STOREID, data, reply);
243     EXPECT_EQ(status, IPC_STUB_INVALID_DATA_ERR);
244 }
245 
246 /**
247  * @tc.name: OnAfterCreate003
248  * @tc.desc: Test OnAfterCreate
249  * @tc.type: FUNC
250  * @tc.require:
251  */
252 HWTEST_F(KVDBServiceStubTest, OnAfterCreate003, TestSize.Level1)
253 {
254     MessageParcel data;
255     data.WriteInterfaceToken(INTERFACE_TOKEN);
256     MessageParcel reply;
257     Options options;
258     options.hapName = INVALID_HAPNAME;
259     ITypesUtil::Marshal(data, options);
260     auto status = kvdbServiceStub->OnAfterCreate(APPID, STOREID, data, reply);
261     EXPECT_EQ(status, IPC_STUB_INVALID_DATA_ERR);
262 }
263 
264 /**
265  * @tc.name: OnSync
266  * @tc.desc: Test OnSync
267  * @tc.type: FUNC
268  * @tc.require:
269  */
270 HWTEST_F(KVDBServiceStubTest, OnSync, TestSize.Level1)
271 {
272     MessageParcel data;
273     data.WriteInterfaceToken(INTERFACE_TOKEN);
274     MessageParcel reply;
275     AppId appId = {"testAppId01"};
276     StoreId storeId = {"testStoreId01"};
277     auto status = kvdbServiceStub->OnSync(appId, storeId, data, reply);
278     EXPECT_EQ(status, IPC_STUB_INVALID_DATA_ERR);
279 }
280 
281 /**
282  * @tc.name: OnRegServiceNotifier
283  * @tc.desc: Test OnRegServiceNotifier
284  * @tc.type: FUNC
285  * @tc.require:
286  */
287 HWTEST_F(KVDBServiceStubTest, OnRegServiceNotifier, TestSize.Level1)
288 {
289     MessageParcel data;
290     MessageParcel reply;
291     AppId appId = {"testApp"};
292     StoreId storeId = {"testStore"};
293     auto status = kvdbServiceStub->OnRegServiceNotifier(appId, storeId, data, reply);
294     EXPECT_EQ(status, ERR_NONE);
295 }
296 
297 /**
298  * @tc.name: OnSetSyncParam
299  * @tc.desc: Test OnSetSyncParam
300  * @tc.type: FUNC
301  * @tc.require:
302  */
303 HWTEST_F(KVDBServiceStubTest, OnSetSyncParam, TestSize.Level1)
304 {
305     MessageParcel data;
306     MessageParcel reply;
307     AppId appId = {"testApp"};
308     StoreId storeId = {"testStore"};
309     auto status = kvdbServiceStub->OnSetSyncParam(appId, storeId, data, reply);
310     EXPECT_EQ(status, IPC_STUB_INVALID_DATA_ERR);
311 }
312 
313 /**
314  * @tc.name: OnAddSubInfo
315  * @tc.desc: Test OnAddSubInfo
316  * @tc.type: FUNC
317  * @tc.require:
318  */
319 HWTEST_F(KVDBServiceStubTest, OnAddSubInfo, TestSize.Level1)
320 {
321     MessageParcel data;
322     MessageParcel reply;
323     AppId appId = {"testApp"};
324     StoreId storeId = {"testStore"};
325     auto status = kvdbServiceStub->OnAddSubInfo(appId, storeId, data, reply);
326     EXPECT_EQ(status, IPC_STUB_INVALID_DATA_ERR);
327 
328     status = kvdbServiceStub->OnRmvSubInfo(appId, storeId, data, reply);
329     EXPECT_EQ(status, IPC_STUB_INVALID_DATA_ERR);
330 }
331 
332 /**
333  * @tc.name: OnRmvSubInfo
334  * @tc.desc: Test OnRmvSubInfo
335  * @tc.type: FUNC
336  * @tc.require:
337  */
338 HWTEST_F(KVDBServiceStubTest, OnRmvSubInfo, TestSize.Level1)
339 {
340     MessageParcel data;
341     MessageParcel reply;
342     AppId appId = {"testApp"};
343     StoreId storeId = {"testStore"};
344     auto status = kvdbServiceStub->OnRmvSubInfo(appId, storeId, data, reply);
345     EXPECT_EQ(status, IPC_STUB_INVALID_DATA_ERR);
346 }
347 
348 /**
349  * @tc.name: OnPutSwitch
350  * @tc.desc: Test OnPutSwitch
351  * @tc.type: FUNC
352  * @tc.require:
353  */
354 HWTEST_F(KVDBServiceStubTest, OnPutSwitch, TestSize.Level1)
355 {
356     MessageParcel data;
357     MessageParcel reply;
358     AppId appId = {"testApp"};
359     StoreId storeId = {"testStore"};
360     auto status = kvdbServiceStub->OnPutSwitch(appId, storeId, data, reply);
361     EXPECT_EQ(status, IPC_STUB_INVALID_DATA_ERR);
362 
363     status = kvdbServiceStub->OnGetSwitch(appId, storeId, data, reply);
364     EXPECT_EQ(status, IPC_STUB_INVALID_DATA_ERR);
365 }
366 
367 /**
368  * @tc.name: OnGetBackupPassword
369  * @tc.desc: Test OnGetBackupPassword
370  * @tc.type: FUNC
371  * @tc.require:
372  */
373 HWTEST_F(KVDBServiceStubTest, OnGetBackupPassword, TestSize.Level1)
374 {
375     MessageParcel data;
376     MessageParcel reply;
377     AppId appId = {"testApp"};
378     StoreId storeId = {"testStore"};
379     auto status = kvdbServiceStub->OnGetBackupPassword(appId, storeId, data, reply);
380     EXPECT_EQ(status, IPC_STUB_INVALID_DATA_ERR);
381 }
382 
383 /**
384  * @tc.name: OnSubscribeSwitchData
385  * @tc.desc: Test OnSubscribeSwitchData
386  * @tc.type: FUNC
387  * @tc.require:
388  */
389 HWTEST_F(KVDBServiceStubTest, OnSubscribeSwitchData, TestSize.Level1)
390 {
391     MessageParcel data;
392     MessageParcel reply;
393     AppId appId = {"appId"};
394     StoreId storeId = {"storeId"};
395     auto status = kvdbServiceStub->OnSubscribeSwitchData(appId, storeId, data, reply);
396     EXPECT_EQ(status, ERR_NONE);
397 
398     status = kvdbServiceStub->OnUnsubscribeSwitchData(appId, storeId, data, reply);
399     EXPECT_EQ(status, ERR_NONE);
400 }
401 
402 /**
403  * @tc.name: OnSetConfig
404  * @tc.desc: Test OnSetConfig
405  * @tc.type: FUNC
406  * @tc.require:
407  */
408 HWTEST_F(KVDBServiceStubTest, OnSetConfig, TestSize.Level1)
409 {
410     MessageParcel data;
411     MessageParcel reply;
412     AppId appId = {"appId"};
413     StoreId storeId = {"storeId"};
414     auto status = kvdbServiceStub->OnSetConfig(appId, storeId, data, reply);
415     EXPECT_EQ(status, IPC_STUB_INVALID_DATA_ERR);
416 }
417 
418 /**
419  * @tc.name: OnRemoveDeviceData
420  * @tc.desc: Test OnRemoveDeviceData
421  * @tc.type: FUNC
422  * @tc.require:
423  */
424 HWTEST_F(KVDBServiceStubTest, OnRemoveDeviceData, TestSize.Level1)
425 {
426     MessageParcel data;
427     MessageParcel reply;
428     AppId appId = {"appId"};
429     StoreId storeId = {"storeId"};
430     auto status = kvdbServiceStub->OnRemoveDeviceData(appId, storeId, data, reply);
431     EXPECT_EQ(status, IPC_STUB_INVALID_DATA_ERR);
432 }
433 
434 /**
435  * @tc.name: IsValidField001
436  * @tc.desc: IsValidField function test.
437  * @tc.type: FUNC
438  */
439 HWTEST_F(KVDBServiceStubTest, IsValidField001, TestSize.Level0)
440 {
441     EXPECT_TRUE(kvdbServiceStub->IsValidField("validpath"));
442     EXPECT_TRUE(kvdbServiceStub->IsValidField("another_valid_path"));
443     EXPECT_TRUE(kvdbServiceStub->IsValidField("file123"));
444 }
445 
446 /**
447  * @tc.name: IsValidField002
448  * @tc.desc: IsValidField function test.
449  * @tc.type: FUNC
450  */
451 HWTEST_F(KVDBServiceStubTest, IsValidField002, TestSize.Level0)
452 {
453     EXPECT_FALSE(kvdbServiceStub->IsValidField("path/with/forward/slash"));
454     EXPECT_FALSE(kvdbServiceStub->IsValidField("/starting/slash"));
455     EXPECT_FALSE(kvdbServiceStub->IsValidField("ending/slash/"));
456     EXPECT_FALSE(kvdbServiceStub->IsValidField("path\\with\\backslash"));
457     EXPECT_FALSE(kvdbServiceStub->IsValidField("\\starting\\ending"));
458     EXPECT_FALSE(kvdbServiceStub->IsValidField("ending\\"));
459     EXPECT_FALSE(kvdbServiceStub->IsValidField(".."));
460     EXPECT_FALSE(kvdbServiceStub->IsValidField("path/with\\mixed/slashes"));
461     EXPECT_FALSE(kvdbServiceStub->IsValidField("path\\with/mixed\\slashes"));
462 }
463 
464 
465 } // namespace DistributedDataTest
466 } // namespace OHOS::Test