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
16 #include "UTTest_kv_adapter_manager.h"
17 #include "datetime_ex.h"
18 #include "dm_constants.h"
19 #include "dm_anonymous.h"
20
21 using ::testing::_;
22 using ::testing::An;
23 using ::testing::Return;
24 using ::testing::DoAll;
25 using ::testing::AtLeast;
26 using ::testing::InSequence;
27 using ::testing::SetArgReferee;
28
29 using namespace OHOS::DistributedKv;
30 namespace OHOS {
31 namespace DistributedHardware {
32 namespace {
33 const std::string KEY = "KEY_";
34 const std::string APPID = "APPID_";
35 const size_t ARG_FIRST = 0;
36 const size_t ARG_SECOND = 1;
37 const size_t ARG_THIRD = 2;
38 const size_t ARG_FOURTH = 3;
39 constexpr int64_t ANCHOR_TIME = 2025;
40 constexpr const char* UDID_HASH_KEY = "udidHash";
41 constexpr const char* APP_ID_KEY = "appID";
42 constexpr const char* ANOY_DEVICE_ID_KEY = "anoyDeviceId";
43 constexpr const char* SALT_KEY = "salt";
44 constexpr const char* LAST_MODIFY_TIME_KEY = "lastModifyTime";
45 } // namespace
SetUp()46 void KVAdapterManagerTest::SetUp()
47 {
48 InitKvStoreEnv();
49 }
50
TearDown()51 void KVAdapterManagerTest::TearDown()
52 {
53 UnInitKvStoreEnv();
54 }
55
SetUpTestCase()56 void KVAdapterManagerTest::SetUpTestCase()
57 {}
58
TearDownTestCase()59 void KVAdapterManagerTest::TearDownTestCase()
60 {}
61
InitKvStoreEnv()62 bool KVAdapterManagerTest::InitKvStoreEnv()
63 {
64 auto kvDataMgr = IDistributedKvDataManager::GetOrCreateDistributedKvDataManager();
65 kvDataMgr_ = std::static_pointer_cast<DistributedKvDataManagerMock>(kvDataMgr);
66 mockSingleKvStore_ = std::make_shared<MockSingleKvStore>();
67 if (!kvDataMgr_ || !mockSingleKvStore_) {
68 return false;
69 }
70 EXPECT_CALL(*kvDataMgr_, GetSingleKvStore(_, _, _, _))
71 .WillOnce(DoAll(SetArgReferee<ARG_FOURTH>(mockSingleKvStore_), Return(Status::SUCCESS)));
72 EXPECT_CALL(*kvDataMgr_, RegisterKvStoreServiceDeathRecipient(_)).Times(1);
73 return KVAdapterManager::GetInstance().Init() == DM_OK;
74 }
75
UnInitKvStoreEnv()76 bool KVAdapterManagerTest::UnInitKvStoreEnv()
77 {
78 if (!kvDataMgr_ || !mockSingleKvStore_) {
79 return false;
80 }
81 EXPECT_CALL(*kvDataMgr_, UnRegisterKvStoreServiceDeathRecipient(_)).Times(1);
82 KVAdapterManager::GetInstance().UnInit();
83 IDistributedKvDataManager::ReleaseDistributedKvDataManager();
84 mockSingleKvStore_.reset();
85 mockSingleKvStore_ = nullptr;
86 return true;
87 }
88
CreateDmKVValueStr(const std::string & appId,int64_t lastModifyTime) const89 std::string KVAdapterManagerTest::CreateDmKVValueStr(const std::string &appId, int64_t lastModifyTime) const
90 {
91 JsonObject jsonObject;
92 jsonObject[UDID_HASH_KEY] = "udid";
93 jsonObject[APP_ID_KEY] = appId;
94 jsonObject[ANOY_DEVICE_ID_KEY] = "anoy_device";
95 jsonObject[SALT_KEY] = "salt";
96 jsonObject[LAST_MODIFY_TIME_KEY] = lastModifyTime;
97 return SafetyDump(jsonObject);
98 }
99
100 HWTEST_F(KVAdapterManagerTest, Init_001, testing::ext::TestSize.Level0)
101 {
102 ASSERT_TRUE(kvDataMgr_ != nullptr);
103 EXPECT_CALL(*kvDataMgr_, GetSingleKvStore(_, _, _, _))
104 .WillRepeatedly(DoAll(SetArgReferee<ARG_FOURTH>(mockSingleKvStore_), Return(Status::DATA_CORRUPTED)));
105 EXPECT_CALL(*kvDataMgr_, CloseKvStore(_, An<const StoreId &>())).WillRepeatedly(Return(Status::SUCCESS));
106 EXPECT_CALL(*kvDataMgr_, DeleteKvStore(_, _, _)).WillRepeatedly(Return(Status::SUCCESS));
107 auto ret = KVAdapterManager::GetInstance().Init();
108 EXPECT_EQ(ret, DM_OK);
109 }
110
111 HWTEST_F(KVAdapterManagerTest, ReInit_001, testing::ext::TestSize.Level0)
112 {
113 ASSERT_TRUE(kvDataMgr_ != nullptr);
114 EXPECT_CALL(*kvDataMgr_, GetSingleKvStore(_, _, _, _))
115 .WillOnce(DoAll(SetArgReferee<ARG_FOURTH>(mockSingleKvStore_), Return(Status::SUCCESS)));
116 EXPECT_CALL(*kvDataMgr_, RegisterKvStoreServiceDeathRecipient(_)).Times(AtLeast(1));
117 EXPECT_CALL(*kvDataMgr_, UnRegisterKvStoreServiceDeathRecipient(_)).Times(AtLeast(1));
118 KVAdapterManager::GetInstance().ReInit();
119 }
120
121 HWTEST_F(KVAdapterManagerTest, PutByAnoyDeviceId_001, testing::ext::TestSize.Level0)
122 {
123 ASSERT_TRUE(mockSingleKvStore_ != nullptr);
124
125 std::string key = "key_1";
126 std::string appId = "appId_1";
127 int64_t nowTime = GetSecondsSince1970ToNow();
128 auto kVValueStr = CreateDmKVValueStr(appId, nowTime);
129 DmKVValue kVValue;
130 ConvertJsonToDmKVValue(kVValueStr, kVValue);
131 {
132 InSequence s;
133 EXPECT_CALL(*mockSingleKvStore_, Put(_, _)).WillOnce(Return(Status::SUCCESS));
134 EXPECT_CALL(*mockSingleKvStore_, Put(_, _)).WillOnce(Return(Status::SUCCESS));
135 }
136 auto ret = KVAdapterManager::GetInstance().PutByAnoyDeviceId(key, kVValue);
137 EXPECT_EQ(ret, DM_OK);
138
139 // @tc.expect: Kv value is existed.
140 ret = KVAdapterManager::GetInstance().PutByAnoyDeviceId(key, kVValue);
141 EXPECT_EQ(ret, DM_OK);
142 }
143
144 HWTEST_F(KVAdapterManagerTest, PutByAnoyDeviceId_002, testing::ext::TestSize.Level2)
145 {
146 ASSERT_TRUE(mockSingleKvStore_ != nullptr);
147
148 std::string key = "key_1";
149 std::string appId = "appId_1";
150 int64_t nowTime = GetSecondsSince1970ToNow();
151 auto kVValueStr = CreateDmKVValueStr(appId, nowTime);
152 DmKVValue kVValue;
153 ConvertJsonToDmKVValue(kVValueStr, kVValue);
154 EXPECT_CALL(*mockSingleKvStore_, Put(_, _)).WillRepeatedly(Return(Status::ERROR));
155 auto ret = KVAdapterManager::GetInstance().PutByAnoyDeviceId(key, kVValue);
156 EXPECT_EQ(ret, ERR_DM_FAILED);
157 }
158
159 HWTEST_F(KVAdapterManagerTest, PutByAnoyDeviceId_003, testing::ext::TestSize.Level2)
160 {
161 ASSERT_TRUE(mockSingleKvStore_ != nullptr);
162
163 std::string key = "key_1";
164 std::string appId = "appId_1";
165 int64_t nowTime = GetSecondsSince1970ToNow();
166 auto kVValueStr = CreateDmKVValueStr(appId, nowTime);
167 DmKVValue kVValue;
168 ConvertJsonToDmKVValue(kVValueStr, kVValue);
169 {
170 InSequence s;
171 EXPECT_CALL(*mockSingleKvStore_, Put(_, _)).WillOnce(Return(Status::SUCCESS));
172 EXPECT_CALL(*mockSingleKvStore_, Put(_, _)).WillOnce(Return(Status::ERROR));
173 }
174 auto ret = KVAdapterManager::GetInstance().PutByAnoyDeviceId(key, kVValue);
175 EXPECT_EQ(ret, ERR_DM_FAILED);
176 }
177
178 HWTEST_F(KVAdapterManagerTest, Get_001, testing::ext::TestSize.Level0)
179 {
180 ASSERT_TRUE(mockSingleKvStore_ != nullptr);
181
182 std::string key = "key_1";
183 std::string appId = "appId_1";
184 int64_t nowTime = GetSecondsSince1970ToNow();
185 auto kVValueStr = CreateDmKVValueStr(appId, nowTime);
186 DmKVValue kVValue;
187 ConvertJsonToDmKVValue(kVValueStr, kVValue);
188 EXPECT_CALL(*mockSingleKvStore_, Get(_, _))
189 .WillOnce(DoAll(SetArgReferee<ARG_SECOND>(kVValueStr), Return(Status::SUCCESS)));
190 auto ret = KVAdapterManager::GetInstance().Get(key, kVValue);
191 EXPECT_EQ(ret, DM_OK);
192
193 ret = KVAdapterManager::GetInstance().Get(key, kVValue);
194 EXPECT_EQ(ret, DM_OK);
195 }
196
197 HWTEST_F(KVAdapterManagerTest, Get_002, testing::ext::TestSize.Level2)
198 {
199 ASSERT_TRUE(mockSingleKvStore_ != nullptr);
200
201 std::string key = "key_1";
202 std::string appId = "appId_1";
203 int64_t nowTime = GetSecondsSince1970ToNow();
204 auto kVValueStr = CreateDmKVValueStr(appId, nowTime);
205 DmKVValue kVValue;
206 ConvertJsonToDmKVValue(kVValueStr, kVValue);
207 EXPECT_CALL(*mockSingleKvStore_, Get(_, _))
208 .WillOnce(Return(Status::ERROR));
209 auto ret = KVAdapterManager::GetInstance().Get(key, kVValue);
210 EXPECT_EQ(ret, ERR_DM_FAILED);
211 }
212
213 HWTEST_F(KVAdapterManagerTest, DeleteAgedEntry_001, testing::ext::TestSize.Level0)
214 {
215 ASSERT_TRUE(mockSingleKvStore_ != nullptr);
216 for (int64_t i = 0; i < 2; ++i) {
217 std::string key = KEY + std::to_string(i);
218 std::string appId = APPID + std::to_string(i);
219 bool isTimeOutFlag = true;
220 if (i % 2) {
221 isTimeOutFlag = true;
222 } else {
223 isTimeOutFlag = false;
224 }
225 int64_t nowTime = !isTimeOutFlag ? GetSecondsSince1970ToNow() : ANCHOR_TIME + i;
226 auto kVValueStr = CreateDmKVValueStr(appId, nowTime);
227 DmKVValue kVValue;
228 ConvertJsonToDmKVValue(kVValueStr, kVValue);
229 {
230 InSequence s;
231 EXPECT_CALL(*mockSingleKvStore_, Put(_, _)).WillOnce(Return(Status::SUCCESS));
232 EXPECT_CALL(*mockSingleKvStore_, Put(_, _)).WillOnce(Return(Status::SUCCESS));
233 }
234 KVAdapterManager::GetInstance().PutByAnoyDeviceId(key, kVValue);
235 }
236
237 auto ret = KVAdapterManager::GetInstance().DeleteAgedEntry();
238 EXPECT_EQ(ret, DM_OK);
239 }
240
241 HWTEST_F(KVAdapterManagerTest, AppUnintall_001, testing::ext::TestSize.Level0)
242 {
243 ASSERT_TRUE(mockSingleKvStore_ != nullptr);
244 std::map<std::string, std::string> registerMap;
245 for (int64_t i = 0; i < 2; ++i) {
246 std::string key = KEY + std::to_string(i);
247 std::string appId = APPID + std::to_string(i);
248 bool isTimeOutFlag = true;
249 if (i % 2) {
250 isTimeOutFlag = true;
251 } else {
252 isTimeOutFlag = false;
253 }
254 int64_t nowTime = !isTimeOutFlag ? GetSecondsSince1970ToNow() : ANCHOR_TIME + i;
255 auto kVValueStr = CreateDmKVValueStr(appId, nowTime);
256 DmKVValue kVValue;
257 ConvertJsonToDmKVValue(kVValueStr, kVValue);
258 {
259 InSequence s;
260 EXPECT_CALL(*mockSingleKvStore_, Put(_, _)).WillOnce(Return(Status::SUCCESS));
261 EXPECT_CALL(*mockSingleKvStore_, Put(_, _)).WillOnce(Return(Status::SUCCESS));
262 }
263 KVAdapterManager::GetInstance().PutByAnoyDeviceId(key, kVValue);
264 registerMap.emplace(key, appId);
265 }
266 ASSERT_FALSE(registerMap.empty());
267 std::vector<DistributedKv::Entry> entrys;
268 for (const auto& item : registerMap) {
269 if (item.first.empty()) {
270 continue;
271 }
272 DistributedKv::Entry entry;
273 entry.key = item.first;
274 entry.value = item.second;
275 entrys.emplace_back(entry);
276 }
277 EXPECT_CALL(*mockSingleKvStore_, GetEntries(An<const Key &>(), _))
278 .WillOnce(DoAll(SetArgReferee<ARG_SECOND>(entrys), Return(Status::SUCCESS)));
279 EXPECT_CALL(*mockSingleKvStore_, DeleteBatch(_))
280 .WillRepeatedly(Return(Status::SUCCESS));
281 auto ret = KVAdapterManager::GetInstance().AppUnintall(registerMap.rbegin()->second);
282 EXPECT_EQ(ret, DM_OK);
283 }
284 } // namespace DistributedHardware
285 } // namespace OHOS
286