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 OHOS::DistributedKv::StoreId storeId = { "kvdb_test_storeid" }; 38 static OHOS::DistributedKv::AppId appId = { "ohos.test.kvdb" }; 39 namespace OHOS::Test { 40 namespace DistributedDataTest { 41 class KVDBServiceStubTest : public testing::Test { 42 public: SetUpTestCase(void)43 static void SetUpTestCase(void) {}; TearDownTestCase(void)44 static void TearDownTestCase(void) {}; SetUp()45 void SetUp() {}; TearDown()46 void TearDown() {}; 47 }; 48 std::shared_ptr<DistributedKv::KVDBServiceImpl> kvdbServiceImpl = std::make_shared<DistributedKv::KVDBServiceImpl>(); 49 std::shared_ptr<KVDBServiceStub> kvdbServiceStub = kvdbServiceImpl; 50 51 /** 52 * @tc.name: OnRemoteRequest_Test_001 53 * @tc.desc: Test OnRemoteRequest 54 * @tc.type: FUNC 55 * @tc.require: 56 */ 57 HWTEST_F(KVDBServiceStubTest, OnRemoteRequest, TestSize.Level1) 58 { 59 MessageParcel data; 60 MessageParcel reply; 61 uint32_t code = 0; 62 auto result = kvdbServiceStub->OnRemoteRequest(code, data, reply); 63 EXPECT_EQ(result, -1); 64 } 65 66 /** 67 * @tc.name: OnRemoteRequest_Test_001 68 * @tc.desc: Test OnRemoteRequest 69 * @tc.type: FUNC 70 * @tc.require: 71 */ 72 HWTEST_F(KVDBServiceStubTest, OnRemoteRequest001, TestSize.Level1) 73 { 74 MessageParcel data; 75 MessageParcel reply; 76 uint32_t code = static_cast<uint32_t>(DistributedKv::KVDBServiceInterfaceCode::TRANS_HEAD) - 1; 77 auto result = kvdbServiceStub->OnRemoteRequest(code, data, reply); 78 EXPECT_EQ(result, -1); 79 80 // Test code greater than TRANS_BUTT 81 code = static_cast<uint32_t>(DistributedKv::KVDBServiceInterfaceCode::TRANS_BUTT); 82 result = kvdbServiceStub->OnRemoteRequest(code, data, reply); 83 EXPECT_EQ(result, -1); 84 } 85 86 /** 87 * @tc.name: GetStoreInfo 88 * @tc.desc: Test GetStoreInfo 89 * @tc.type: FUNC 90 * @tc.require: 91 */ 92 HWTEST_F(KVDBServiceStubTest, GetStoreInfo, TestSize.Level1) 93 { 94 MessageParcel data; 95 auto [status, info] = kvdbServiceStub->GetStoreInfo(0, data); 96 EXPECT_EQ(status, IPC_STUB_INVALID_DATA_ERR); 97 } 98 99 /** 100 * @tc.name: GetStoreInfo 101 * @tc.desc: Test GetStoreInfo 102 * @tc.type: FUNC 103 * @tc.require: 104 */ 105 HWTEST_F(KVDBServiceStubTest, GetStoreInfo001, TestSize.Level1) 106 { 107 MessageParcel data; 108 AppId appId = {"test_app"}; 109 StoreId storeId = {"test_store"}; 110 auto [status, info] = kvdbServiceStub->GetStoreInfo(0, data); 111 EXPECT_EQ(status, IPC_STUB_INVALID_DATA_ERR); 112 EXPECT_EQ(info.bundleName, ""); 113 EXPECT_EQ(info.storeId, ""); 114 } 115 116 /** 117 * @tc.name: CheckPermission 118 * @tc.desc: Test CheckPermission 119 * @tc.type: FUNC 120 * @tc.require: 121 */ 122 HWTEST_F(KVDBServiceStubTest, CheckPermission, TestSize.Level1) 123 { 124 KVDBServiceStub::StoreInfo info; 125 info.bundleName = "test_bundleName"; 126 info.storeId = "test_storeId"; 127 uint32_t code = static_cast<uint32_t>(DistributedKv::KVDBServiceInterfaceCode::TRANS_PUT_SWITCH); 128 auto status = kvdbServiceStub->CheckPermission(code, info); 129 EXPECT_FALSE(status); 130 131 code = static_cast<uint32_t>(DistributedKv::KVDBServiceInterfaceCode::TRANS_UNSUBSCRIBE_SWITCH_DATA); 132 status = kvdbServiceStub->CheckPermission(code, info); 133 EXPECT_FALSE(status); 134 } 135 136 /** 137 * @tc.name: CheckPermission 138 * @tc.desc: Test CheckPermission 139 * @tc.type: FUNC 140 * @tc.require: 141 */ 142 HWTEST_F(KVDBServiceStubTest, CheckPermission001, TestSize.Level1) 143 { 144 KVDBServiceStub::StoreInfo info; 145 info.bundleName = "validApp"; 146 info.storeId = "validStore"; 147 EXPECT_FALSE(kvdbServiceStub->CheckPermission(0, info)); 148 } 149 150 151 /** 152 * @tc.name: OnBeforeCreate 153 * @tc.desc: Test OnBeforeCreate 154 * @tc.type: FUNC 155 * @tc.require: 156 */ 157 HWTEST_F(KVDBServiceStubTest, OnBeforeCreate, TestSize.Level1) 158 { 159 MessageParcel data; 160 MessageParcel reply; 161 AppId appId = {"testApp"}; 162 StoreId storeId = {"testStoreId"}; 163 auto status = kvdbServiceStub->OnBeforeCreate(appId, storeId, data, reply); 164 EXPECT_EQ(status, IPC_STUB_INVALID_DATA_ERR); 165 } 166 167 /** 168 * @tc.name: OnAfterCreate 169 * @tc.desc: Test OnAfterCreate 170 * @tc.type: FUNC 171 * @tc.require: 172 */ 173 HWTEST_F(KVDBServiceStubTest, OnAfterCreate, TestSize.Level1) 174 { 175 MessageParcel data; 176 data.WriteInterfaceToken(INTERFACE_TOKEN); 177 MessageParcel reply; 178 AppId appId = {"testApp"}; 179 StoreId storeId = {"testStore"}; 180 auto status = kvdbServiceStub->OnAfterCreate(appId, storeId, data, reply); 181 EXPECT_EQ(status, IPC_STUB_INVALID_DATA_ERR); 182 } 183 184 /** 185 * @tc.name: OnSync 186 * @tc.desc: Test OnSync 187 * @tc.type: FUNC 188 * @tc.require: 189 */ 190 HWTEST_F(KVDBServiceStubTest, OnSync, TestSize.Level1) 191 { 192 MessageParcel data; 193 data.WriteInterfaceToken(INTERFACE_TOKEN); 194 MessageParcel reply; 195 AppId appId = {"testAppId01"}; 196 StoreId storeId = {"testStoreId01"}; 197 auto status = kvdbServiceStub->OnSync(appId, storeId, data, reply); 198 EXPECT_EQ(status, IPC_STUB_INVALID_DATA_ERR); 199 } 200 201 /** 202 * @tc.name: OnRegServiceNotifier 203 * @tc.desc: Test OnRegServiceNotifier 204 * @tc.type: FUNC 205 * @tc.require: 206 */ 207 HWTEST_F(KVDBServiceStubTest, OnRegServiceNotifier, TestSize.Level1) 208 { 209 MessageParcel data; 210 MessageParcel reply; 211 AppId appId = {"testApp"}; 212 StoreId storeId = {"testStore"}; 213 auto status = kvdbServiceStub->OnRegServiceNotifier(appId, storeId, data, reply); 214 EXPECT_EQ(status, ERR_NONE); 215 } 216 217 /** 218 * @tc.name: OnSetSyncParam 219 * @tc.desc: Test OnSetSyncParam 220 * @tc.type: FUNC 221 * @tc.require: 222 */ 223 HWTEST_F(KVDBServiceStubTest, OnSetSyncParam, TestSize.Level1) 224 { 225 MessageParcel data; 226 MessageParcel reply; 227 AppId appId = {"testApp"}; 228 StoreId storeId = {"testStore"}; 229 auto status = kvdbServiceStub->OnSetSyncParam(appId, storeId, data, reply); 230 EXPECT_EQ(status, IPC_STUB_INVALID_DATA_ERR); 231 } 232 233 /** 234 * @tc.name: OnAddSubInfo 235 * @tc.desc: Test OnAddSubInfo 236 * @tc.type: FUNC 237 * @tc.require: 238 */ 239 HWTEST_F(KVDBServiceStubTest, OnAddSubInfo, TestSize.Level1) 240 { 241 MessageParcel data; 242 MessageParcel reply; 243 AppId appId = {"testApp"}; 244 StoreId storeId = {"testStore"}; 245 auto status = kvdbServiceStub->OnAddSubInfo(appId, storeId, data, reply); 246 EXPECT_EQ(status, IPC_STUB_INVALID_DATA_ERR); 247 248 status = kvdbServiceStub->OnRmvSubInfo(appId, storeId, data, reply); 249 EXPECT_EQ(status, IPC_STUB_INVALID_DATA_ERR); 250 } 251 252 /** 253 * @tc.name: OnRmvSubInfo 254 * @tc.desc: Test OnRmvSubInfo 255 * @tc.type: FUNC 256 * @tc.require: 257 */ 258 HWTEST_F(KVDBServiceStubTest, OnRmvSubInfo, TestSize.Level1) 259 { 260 MessageParcel data; 261 MessageParcel reply; 262 AppId appId = {"testApp"}; 263 StoreId storeId = {"testStore"}; 264 auto status = kvdbServiceStub->OnRmvSubInfo(appId, storeId, data, reply); 265 EXPECT_EQ(status, IPC_STUB_INVALID_DATA_ERR); 266 } 267 268 /** 269 * @tc.name: OnPutSwitch 270 * @tc.desc: Test OnPutSwitch 271 * @tc.type: FUNC 272 * @tc.require: 273 */ 274 HWTEST_F(KVDBServiceStubTest, OnPutSwitch, TestSize.Level1) 275 { 276 MessageParcel data; 277 MessageParcel reply; 278 AppId appId = {"testApp"}; 279 StoreId storeId = {"testStore"}; 280 auto status = kvdbServiceStub->OnPutSwitch(appId, storeId, data, reply); 281 EXPECT_EQ(status, IPC_STUB_INVALID_DATA_ERR); 282 283 status = kvdbServiceStub->OnGetSwitch(appId, storeId, data, reply); 284 EXPECT_EQ(status, IPC_STUB_INVALID_DATA_ERR); 285 } 286 287 /** 288 * @tc.name: OnGetBackupPassword 289 * @tc.desc: Test OnGetBackupPassword 290 * @tc.type: FUNC 291 * @tc.require: 292 */ 293 HWTEST_F(KVDBServiceStubTest, OnGetBackupPassword, TestSize.Level1) 294 { 295 MessageParcel data; 296 MessageParcel reply; 297 AppId appId = {"testApp"}; 298 StoreId storeId = {"testStore"}; 299 auto status = kvdbServiceStub->OnGetBackupPassword(appId, storeId, data, reply); 300 EXPECT_EQ(status, IPC_STUB_INVALID_DATA_ERR); 301 } 302 303 /** 304 * @tc.name: OnSubscribeSwitchData 305 * @tc.desc: Test OnSubscribeSwitchData 306 * @tc.type: FUNC 307 * @tc.require: 308 */ 309 HWTEST_F(KVDBServiceStubTest, OnSubscribeSwitchData, TestSize.Level1) 310 { 311 MessageParcel data; 312 MessageParcel reply; 313 AppId appId = {"appId"}; 314 StoreId storeId = {"storeId"}; 315 auto status = kvdbServiceStub->OnSubscribeSwitchData(appId, storeId, data, reply); 316 EXPECT_EQ(status, ERR_NONE); 317 318 status = kvdbServiceStub->OnUnsubscribeSwitchData(appId, storeId, data, reply); 319 EXPECT_EQ(status, ERR_NONE); 320 } 321 322 /** 323 * @tc.name: OnSetConfig 324 * @tc.desc: Test OnSetConfig 325 * @tc.type: FUNC 326 * @tc.require: 327 */ 328 HWTEST_F(KVDBServiceStubTest, OnSetConfig, TestSize.Level1) 329 { 330 MessageParcel data; 331 MessageParcel reply; 332 AppId appId = {"appId"}; 333 StoreId storeId = {"storeId"}; 334 auto status = kvdbServiceStub->OnSetConfig(appId, storeId, data, reply); 335 EXPECT_EQ(status, IPC_STUB_INVALID_DATA_ERR); 336 } 337 338 /** 339 * @tc.name: OnRemoveDeviceData 340 * @tc.desc: Test OnRemoveDeviceData 341 * @tc.type: FUNC 342 * @tc.require: 343 */ 344 HWTEST_F(KVDBServiceStubTest, OnRemoveDeviceData, TestSize.Level1) 345 { 346 MessageParcel data; 347 MessageParcel reply; 348 AppId appId = {"appId"}; 349 StoreId storeId = {"storeId"}; 350 auto status = kvdbServiceStub->OnRemoveDeviceData(appId, storeId, data, reply); 351 EXPECT_EQ(status, IPC_STUB_INVALID_DATA_ERR); 352 } 353 } // namespace DistributedDataTest 354 } // namespace OHOS::Test