• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2024 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 "bootstrap.h"
17 #include "kvstore_meta_manager.h"
18 
19 #include "metadata/appid_meta_data.h"
20 #include "metadata/auto_launch_meta_data.h"
21 #include "metadata/appid_meta_data.h"
22 #include "metadata/capability_meta_data.h"
23 #include "metadata/capability_range.h"
24 #include "metadata/corrupted_meta_data.h"
25 #include "metadata/matrix_meta_data.h"
26 #include "metadata/meta_data.h"
27 #include "metadata/meta_data_manager.h"
28 #include "metadata/object_user_meta_data.h"
29 #include "metadata/secret_key_meta_data.h"
30 #include "metadata/store_meta_data.h"
31 #include "metadata/store_meta_data_local.h"
32 #include "metadata/strategy_meta_data.h"
33 #include "metadata/switches_meta_data.h"
34 #include "metadata/user_meta_data.h"
35 #include "metadata/device_meta_data.h"
36 #include "utils/constant.h"
37 #include "gtest/gtest.h"
38 #include "serializable/serializable.h"
39 using namespace testing::ext;
40 using namespace OHOS;
41 using namespace OHOS::DistributedKv;
42 using namespace OHOS::DistributedData;
43 namespace OHOS::Test {
44 class ServiceMetaDataTest : public testing::Test {
45 public:
46     static constexpr size_t NUM_MIN = 1;
47     static constexpr size_t NUM_MAX = 2;
48     static constexpr uint32_t USER_ID1 = 101;
49     static constexpr uint32_t USER_ID2 = 100;
50     static constexpr uint32_t TEST_CURRENT_VERSION = 0x03000002;
SetUpTestCase()51     static void SetUpTestCase()
52     {
53         std::shared_ptr<ExecutorPool> executors = std::make_shared<ExecutorPool>(NUM_MAX, NUM_MIN);
54         Bootstrap::GetInstance().LoadDirectory();
55         Bootstrap::GetInstance().LoadCheckers();
56         KvStoreMetaManager::GetInstance().BindExecutor(executors);
57         KvStoreMetaManager::GetInstance().InitMetaParameter();
58         KvStoreMetaManager::GetInstance().InitMetaListener();
59     }
TearDownTestCase(void)60     static void TearDownTestCase(void) {};
SetUp()61     void SetUp() {};
TearDown()62     void TearDown() {};
63 };
64 
65 /**
66  * @tc.name: AppIDMetaData
67  * @tc.desc:
68  * @tc.type: FUNC
69  * @tc.require:
70  * @tc.author: SQL
71  */
72 HWTEST_F(ServiceMetaDataTest, AppIDMetaData, TestSize.Level1)
73 {
74     AppIDMetaData appIdMetaData("appid", "ohos.test.demo");
75     AppIDMetaData appIdMeta;
76 
77     std::string key = appIdMetaData.GetKey();
78     EXPECT_EQ(key, "appid");
79     auto result = MetaDataManager::GetInstance().SaveMeta(key, appIdMetaData, true);
80     EXPECT_TRUE(result);
81     result = MetaDataManager::GetInstance().LoadMeta(key, appIdMeta, true);
82     EXPECT_TRUE(result);
83     EXPECT_EQ(appIdMetaData.appId, appIdMeta.appId);
84     EXPECT_EQ(appIdMetaData.bundleName, appIdMeta.bundleName);
85     EXPECT_EQ(appIdMetaData.GetKey(), appIdMeta.GetKey());
86     result = MetaDataManager::GetInstance().DelMeta(key, true);
87     EXPECT_TRUE(result);
88 
89     result = MetaDataManager::GetInstance().SaveMeta(key, appIdMetaData);
90     EXPECT_TRUE(result);
91     result = MetaDataManager::GetInstance().LoadMeta(key, appIdMeta);
92     EXPECT_TRUE(result);
93     EXPECT_EQ(appIdMetaData.appId, appIdMeta.appId);
94     EXPECT_EQ(appIdMetaData.bundleName, appIdMeta.bundleName);
95     EXPECT_EQ(appIdMetaData.GetKey(), appIdMeta.GetKey());
96     result = MetaDataManager::GetInstance().DelMeta(key);
97     EXPECT_TRUE(result);
98 }
99 
100 /**
101  * @tc.name: corruptedMeta
102  * @tc.desc:
103  * @tc.type: FUNC
104  * @tc.require:
105  * @tc.author: SQL
106  */
107 HWTEST_F(ServiceMetaDataTest, corruptedMeta, TestSize.Level1)
108 {
109     CorruptedMetaData corruptedMeta("appid", "ohos.test.demo", "test_store");
110     CorruptedMetaData corruptedMetaData;
111     corruptedMeta.isCorrupted = true;
112     std::string key = corruptedMeta.GetKey();
113     EXPECT_EQ(key, "CorruptedMetaData###appid###ohos.test.demo###test_store");
114 
115     auto result = MetaDataManager::GetInstance().SaveMeta(key, corruptedMeta, true);
116     EXPECT_TRUE(result);
117     result = MetaDataManager::GetInstance().LoadMeta(key, corruptedMetaData, true);
118     EXPECT_TRUE(result);
119     EXPECT_EQ(corruptedMeta.appId, corruptedMetaData.appId);
120     EXPECT_EQ(corruptedMeta.bundleName, corruptedMetaData.bundleName);
121     EXPECT_EQ(corruptedMeta.storeId, corruptedMetaData.storeId);
122     EXPECT_EQ(corruptedMeta.GetKey(), corruptedMetaData.GetKey());
123     result = MetaDataManager::GetInstance().DelMeta(key, true);
124     EXPECT_TRUE(result);
125 
126     result = MetaDataManager::GetInstance().SaveMeta(key, corruptedMeta);
127     EXPECT_TRUE(result);
128     result = MetaDataManager::GetInstance().LoadMeta(key, corruptedMetaData);
129     EXPECT_TRUE(result);
130     EXPECT_EQ(corruptedMeta.appId, corruptedMetaData.appId);
131     EXPECT_EQ(corruptedMeta.bundleName, corruptedMetaData.bundleName);
132     EXPECT_EQ(corruptedMeta.storeId, corruptedMetaData.storeId);
133     EXPECT_EQ(corruptedMeta.GetKey(), corruptedMetaData.GetKey());
134     result = MetaDataManager::GetInstance().DelMeta(key);
135     EXPECT_TRUE(result);
136 }
137 
138 /**
139  * @tc.name: SecretKeyMetaData
140  * @tc.desc:
141  * @tc.type: FUNC
142  * @tc.require:
143  * @tc.author: SQL
144  */
145 HWTEST_F(ServiceMetaDataTest, SecretKeyMetaData001, TestSize.Level1)
146 {
147     SecretKeyMetaData secretKeyMeta;
148     SecretKeyMetaData secretKeyMetaData;
149     secretKeyMeta.storeType = 1;
150     std::initializer_list<std::string> fields = { "time", "skey" };
151 
152     std::string key = secretKeyMeta.GetKey(fields);
153     EXPECT_EQ(key, "SecretKey###time###skey###SINGLE_KEY");
154     std::string backupkey = secretKeyMeta.GetBackupKey(fields);
155     EXPECT_EQ(backupkey, "BackupSecretKey###time###skey###");
156 
157     auto result = MetaDataManager::GetInstance().SaveMeta(key, secretKeyMeta, true);
158     EXPECT_TRUE(result);
159     result = MetaDataManager::GetInstance().LoadMeta(key, secretKeyMetaData, true);
160     EXPECT_TRUE(result);
161     EXPECT_EQ(secretKeyMeta.GetKey(fields), secretKeyMetaData.GetKey(fields));
162     EXPECT_EQ(secretKeyMeta.GetBackupKey(fields), secretKeyMetaData.GetBackupKey(fields));
163 
164     result = MetaDataManager::GetInstance().DelMeta(key, true);
165     EXPECT_TRUE(result);
166 
167     result = MetaDataManager::GetInstance().SaveMeta(key, secretKeyMeta);
168     EXPECT_TRUE(result);
169     result = MetaDataManager::GetInstance().LoadMeta(key, secretKeyMetaData);
170     EXPECT_TRUE(result);
171     EXPECT_EQ(secretKeyMeta.GetKey(fields), secretKeyMetaData.GetKey(fields));
172     EXPECT_EQ(secretKeyMeta.GetBackupKey(fields), secretKeyMetaData.GetBackupKey(fields));
173 
174     result = MetaDataManager::GetInstance().DelMeta(key);
175     EXPECT_TRUE(result);
176 }
177 
178 /**
179  * @tc.name: SecretKeyMetaData
180  * @tc.desc:
181  * @tc.type: FUNC
182  * @tc.require:
183  * @tc.author: SQL
184  */
185 HWTEST_F(ServiceMetaDataTest, SecretKeyMetaData002, TestSize.Level1)
186 {
187     SecretKeyMetaData secretKeyMeta;
188     SecretKeyMetaData secretKeyMetaData;
189     secretKeyMeta.storeType = 1;
190     std::initializer_list<std::string> fields = { "time", "skey" };
191 
192     std::string prefix = secretKeyMeta.GetPrefix(fields);
193     EXPECT_EQ(prefix, "SecretKey###time###skey###");
194     std::string backupprefix = secretKeyMeta.GetBackupPrefix(fields);
195     EXPECT_EQ(backupprefix, "BackupSecretKey###time###skey###");
196 
197     auto result = MetaDataManager::GetInstance().SaveMeta(prefix, secretKeyMeta, true);
198     EXPECT_TRUE(result);
199     result = MetaDataManager::GetInstance().LoadMeta(prefix, secretKeyMetaData, true);
200     EXPECT_TRUE(result);
201     EXPECT_EQ(secretKeyMeta.GetPrefix(fields), secretKeyMetaData.GetPrefix(fields));
202     EXPECT_EQ(secretKeyMeta.GetBackupPrefix(fields), secretKeyMetaData.GetBackupPrefix(fields));
203 
204     result = MetaDataManager::GetInstance().DelMeta(prefix, true);
205     EXPECT_TRUE(result);
206 
207     result = MetaDataManager::GetInstance().SaveMeta(prefix, secretKeyMeta);
208     EXPECT_TRUE(result);
209     result = MetaDataManager::GetInstance().LoadMeta(prefix, secretKeyMetaData);
210     EXPECT_TRUE(result);
211     EXPECT_EQ(secretKeyMeta.GetPrefix(fields), secretKeyMetaData.GetPrefix(fields));
212     EXPECT_EQ(secretKeyMeta.GetBackupPrefix(fields), secretKeyMetaData.GetBackupPrefix(fields));
213 
214     result = MetaDataManager::GetInstance().DelMeta(prefix);
215     EXPECT_TRUE(result);
216 }
217 
218 /**
219  * @tc.name: StoreMetaData
220  * @tc.desc:
221  * @tc.type: FUNC
222  * @tc.require:
223  * @tc.author: SQL
224  */
225 HWTEST_F(ServiceMetaDataTest, StoreMetaData001, TestSize.Level1)
226 {
227     StoreMetaData storeMetaData("100", "appid", "test_store");
228     storeMetaData.dataDir = "testDir";
229     StoreMetaData storeMeta;
230 
231     std::string key = storeMetaData.GetKey();
232     EXPECT_EQ(key, "KvStoreMetaData######100###default######test_store###testDir");
233     std::string keylocal = storeMetaData.GetKeyLocal();
234     EXPECT_EQ(keylocal, "KvStoreMetaDataLocal######100###default######test_store###testDir");
235     std::initializer_list<std::string> fields = { "100", "appid", "test_store" };
236     std::string keyfields = storeMetaData.GetKey(fields);
237     EXPECT_EQ(keyfields, "KvStoreMetaData###100###appid###test_store");
238 
239     auto result = MetaDataManager::GetInstance().SaveMeta(key, storeMetaData, true);
240     EXPECT_TRUE(result);
241     result = MetaDataManager::GetInstance().LoadMeta(key, storeMeta, true);
242     EXPECT_TRUE(result);
243     EXPECT_EQ(storeMetaData.GetKey(), storeMeta.GetKey());
244     EXPECT_EQ(storeMetaData.GetKeyLocal(), storeMeta.GetKeyLocal());
245     EXPECT_EQ(storeMetaData.GetKey(fields), storeMeta.GetKey(fields));
246 
247     result = MetaDataManager::GetInstance().DelMeta(key, true);
248     EXPECT_TRUE(result);
249 
250     std::string syncKey = storeMetaData.GetKeyWithoutPath();
251     result = MetaDataManager::GetInstance().SaveMeta(syncKey, storeMetaData);
252     EXPECT_TRUE(result);
253     result = MetaDataManager::GetInstance().LoadMeta(syncKey, storeMeta);
254     EXPECT_TRUE(result);
255     EXPECT_EQ(storeMetaData.GetKey(), storeMeta.GetKey());
256     EXPECT_EQ(storeMetaData.GetKeyLocal(), storeMeta.GetKeyLocal());
257     EXPECT_EQ(storeMetaData.GetKey(fields), storeMeta.GetKey(fields));
258 
259     result = MetaDataManager::GetInstance().DelMeta(syncKey);
260     EXPECT_TRUE(result);
261 }
262 
263 /**
264  * @tc.name: StoreMetaData
265  * @tc.desc:
266  * @tc.type: FUNC
267  * @tc.require:
268  * @tc.author: SQL
269  */
270 HWTEST_F(ServiceMetaDataTest, StoreMetaData002, TestSize.Level1)
271 {
272     StoreMetaData storeMetaData("100", "appid", "test_store");
273     storeMetaData.dataDir = "testDir";
274     StoreMetaData storeMeta;
275 
276     std::string secretkey = storeMetaData.GetSecretKey();
277     EXPECT_EQ(secretkey, "SecretKey###100###default######test_store###0###testDir###SINGLE_KEY");
278     std::string backupsecretkey = storeMetaData.GetBackupSecretKey();
279     EXPECT_EQ(backupsecretkey, "BackupSecretKey###100###default######test_store###0###");
280 
281     auto result = MetaDataManager::GetInstance().SaveMeta(secretkey, storeMetaData, true);
282     EXPECT_TRUE(result);
283     result = MetaDataManager::GetInstance().LoadMeta(secretkey, storeMeta, true);
284     EXPECT_TRUE(result);
285     EXPECT_EQ(storeMetaData.GetSecretKey(), storeMeta.GetSecretKey());
286     EXPECT_EQ(storeMetaData.GetBackupSecretKey(), storeMeta.GetBackupSecretKey());
287 
288     result = MetaDataManager::GetInstance().DelMeta(secretkey, true);
289     EXPECT_TRUE(result);
290 
291     result = MetaDataManager::GetInstance().SaveMeta(secretkey, storeMetaData);
292     EXPECT_TRUE(result);
293     result = MetaDataManager::GetInstance().LoadMeta(secretkey, storeMeta);
294     EXPECT_TRUE(result);
295     EXPECT_EQ(storeMetaData.GetSecretKey(), storeMeta.GetSecretKey());
296     EXPECT_EQ(storeMetaData.GetBackupSecretKey(), storeMeta.GetBackupSecretKey());
297 
298     result = MetaDataManager::GetInstance().DelMeta(secretkey);
299     EXPECT_TRUE(result);
300 }
301 
302 /**
303  * @tc.name: StoreMetaData
304  * @tc.desc:
305  * @tc.type: FUNC
306  * @tc.require:
307  * @tc.author: SQL
308  */
309 HWTEST_F(ServiceMetaDataTest, StoreMetaData003, TestSize.Level1)
310 {
311     StoreMetaData storeMetaData("100", "appid", "test_store");
312     StoreMetaData storeMeta;
313 
314     auto storealias = storeMetaData.GetStoreAlias();
315     EXPECT_EQ(storealias, "test_store");
316     std::string strategykey = storeMetaData.GetStrategyKey();
317     EXPECT_EQ(strategykey, "StrategyMetaData######100###default######test_store");
318     std::initializer_list<std::string> fields = { "100", "appid", "test_store" };
319     std::string prefix = storeMetaData.GetPrefix(fields);
320     EXPECT_EQ(prefix, "KvStoreMetaData###100###appid###test_store###");
321 
322     auto result = MetaDataManager::GetInstance().SaveMeta(strategykey, storeMetaData, true);
323     EXPECT_TRUE(result);
324     result = MetaDataManager::GetInstance().LoadMeta(strategykey, storeMeta, true);
325     EXPECT_TRUE(result);
326     EXPECT_EQ(storeMetaData.GetStrategyKey(), storeMeta.GetStrategyKey());
327     EXPECT_EQ(storeMetaData.GetStoreAlias(), storeMeta.GetStoreAlias());
328     EXPECT_EQ(storeMetaData.GetPrefix(fields), storeMeta.GetPrefix(fields));
329 
330     result = MetaDataManager::GetInstance().DelMeta(strategykey, true);
331     EXPECT_TRUE(result);
332 
333     result = MetaDataManager::GetInstance().SaveMeta(strategykey, storeMetaData);
334     EXPECT_TRUE(result);
335     result = MetaDataManager::GetInstance().LoadMeta(strategykey, storeMeta);
336     EXPECT_TRUE(result);
337     EXPECT_EQ(storeMetaData.GetStrategyKey(), storeMeta.GetStrategyKey());
338     EXPECT_EQ(storeMetaData.GetStoreAlias(), storeMeta.GetStoreAlias());
339     EXPECT_EQ(storeMetaData.GetPrefix(fields), storeMeta.GetPrefix(fields));
340 
341     result = MetaDataManager::GetInstance().DelMeta(strategykey);
342     EXPECT_TRUE(result);
343 }
344 
345 /**
346  * @tc.name: StoreMetaData
347  * @tc.desc:
348  * @tc.type: FUNC
349  * @tc.require:
350  * @tc.author: SQL
351  */
352 HWTEST_F(ServiceMetaDataTest, StoreMetaData004, TestSize.Level1)
353 {
354     StoreMetaData storeMetaData("100", "appid", "test_store");
355     storeMetaData.version = TEST_CURRENT_VERSION;
356     storeMetaData.instanceId = 1;
357     storeMetaData.dataDir = "testDir";
358     StoreMetaData storeMeta;
359 
360     std::string key = storeMetaData.GetKey();
361     EXPECT_EQ(key, "KvStoreMetaData######100###default######test_store###1###testDir");
362     std::string keylocal = storeMetaData.GetKeyLocal();
363     EXPECT_EQ(keylocal, "KvStoreMetaDataLocal######100###default######test_store###1###testDir");
364 
365     auto result = MetaDataManager::GetInstance().SaveMeta(key, storeMetaData, true);
366     EXPECT_TRUE(result);
367     result = MetaDataManager::GetInstance().LoadMeta(key, storeMeta, true);
368     EXPECT_TRUE(result);
369     EXPECT_EQ(storeMetaData.GetKey(), storeMeta.GetKey());
370     EXPECT_EQ(storeMetaData.GetKeyLocal(), storeMeta.GetKeyLocal());
371 
372     result = MetaDataManager::GetInstance().DelMeta(key, true);
373     EXPECT_TRUE(result);
374 
375     std::string syncKey = storeMetaData.GetKeyWithoutPath();
376     result = MetaDataManager::GetInstance().SaveMeta(syncKey, storeMetaData);
377     EXPECT_TRUE(result);
378     result = MetaDataManager::GetInstance().LoadMeta(syncKey, storeMeta);
379     EXPECT_TRUE(result);
380     EXPECT_EQ(storeMetaData.GetKey(), storeMeta.GetKey());
381     EXPECT_EQ(storeMetaData.GetKeyLocal(), storeMeta.GetKeyLocal());
382 
383     result = MetaDataManager::GetInstance().DelMeta(syncKey);
384     EXPECT_TRUE(result);
385 }
386 
387 /**
388  * @tc.name: StoreMetaData
389  * @tc.desc:
390  * @tc.type: FUNC
391  * @tc.require:
392  * @tc.author: SQL
393  */
394 HWTEST_F(ServiceMetaDataTest, StoreMetaData005, TestSize.Level1)
395 {
396     StoreMetaData storeMetaData("100", "appid", "test_store");
397     storeMetaData.version = TEST_CURRENT_VERSION;
398     storeMetaData.instanceId = 1;
399     storeMetaData.dataDir = "testDir";
400     StoreMetaData storeMeta;
401 
402     std::string secretkey = storeMetaData.GetSecretKey();
403     EXPECT_EQ(secretkey, "SecretKey###100###default######test_store###testDir###SINGLE_KEY");
404     std::string backupsecretkey = storeMetaData.GetBackupSecretKey();
405     EXPECT_EQ(backupsecretkey, "BackupSecretKey###100###default######test_store###");
406     std::string strategykey = storeMetaData.GetStrategyKey();
407     EXPECT_EQ(strategykey, "StrategyMetaData######100###default######test_store###1");
408 
409     auto result = MetaDataManager::GetInstance().SaveMeta(secretkey, storeMetaData, true);
410     EXPECT_TRUE(result);
411     result = MetaDataManager::GetInstance().LoadMeta(secretkey, storeMeta, true);
412     EXPECT_TRUE(result);
413     EXPECT_EQ(storeMetaData.GetSecretKey(), storeMeta.GetSecretKey());
414     EXPECT_EQ(storeMetaData.GetBackupSecretKey(), storeMeta.GetBackupSecretKey());
415     EXPECT_EQ(storeMetaData.GetStrategyKey(), storeMeta.GetStrategyKey());
416 
417     result = MetaDataManager::GetInstance().DelMeta(secretkey, true);
418     EXPECT_TRUE(result);
419 
420     result = MetaDataManager::GetInstance().SaveMeta(secretkey, storeMetaData);
421     EXPECT_TRUE(result);
422     result = MetaDataManager::GetInstance().LoadMeta(secretkey, storeMeta);
423     EXPECT_TRUE(result);
424     EXPECT_EQ(storeMetaData.GetSecretKey(), storeMeta.GetSecretKey());
425     EXPECT_EQ(storeMetaData.GetBackupSecretKey(), storeMeta.GetBackupSecretKey());
426     EXPECT_EQ(storeMetaData.GetStrategyKey(), storeMeta.GetStrategyKey());
427 
428     result = MetaDataManager::GetInstance().DelMeta(secretkey);
429     EXPECT_TRUE(result);
430 }
431 
432 /**
433  * @tc.name: StoreMetaData
434  * @tc.desc:
435  * @tc.type: FUNC
436  * @tc.require:
437  * @tc.author: SQL
438  */
439 HWTEST_F(ServiceMetaDataTest, StoreMetaData006, TestSize.Level1)
440 {
441     StoreMetaData storemetaData1("100", "appid", "test_store");
442     StoreMetaData storemetaData2("100", "appid", "test_store");
443     StoreMetaData storemetaData3("10", "appid1", "storeid");
444     EXPECT_TRUE(storemetaData1 == storemetaData2);
445     EXPECT_FALSE(storemetaData1 == storemetaData3);
446 
447     storemetaData1.isAutoSync = true;
448     EXPECT_FALSE(storemetaData1 == storemetaData2);
449     storemetaData2.isAutoSync = true;
450     EXPECT_TRUE(storemetaData1 == storemetaData2);
451 
452     storemetaData1.isBackup = true;
453     EXPECT_FALSE(storemetaData1 == storemetaData2);
454     storemetaData2.isBackup = true;
455     EXPECT_TRUE(storemetaData1 == storemetaData2);
456 
457     storemetaData1.isDirty = true;
458     EXPECT_FALSE(storemetaData1 == storemetaData2);
459     storemetaData2.isDirty = true;
460     EXPECT_TRUE(storemetaData1 == storemetaData2);
461 
462     storemetaData1.isEncrypt = true;
463     EXPECT_FALSE(storemetaData1 == storemetaData2);
464     storemetaData2.isEncrypt = true;
465     EXPECT_TRUE(storemetaData1 == storemetaData2);
466 
467     storemetaData1.isSearchable = true;
468     EXPECT_FALSE(storemetaData1 == storemetaData2);
469     storemetaData2.isSearchable = true;
470     EXPECT_TRUE(storemetaData1 == storemetaData2);
471 
472     storemetaData1.isNeedCompress = true;
473     EXPECT_FALSE(storemetaData1 == storemetaData2);
474     storemetaData2.isNeedCompress = true;
475     EXPECT_TRUE(storemetaData1 == storemetaData2);
476 
477     storemetaData1.enableCloud = true;
478     EXPECT_FALSE(storemetaData1 == storemetaData2);
479     storemetaData2.enableCloud = true;
480     EXPECT_TRUE(storemetaData1 == storemetaData2);
481 
482     storemetaData1.cloudAutoSync = true;
483     EXPECT_FALSE(storemetaData1 == storemetaData2);
484     storemetaData2.cloudAutoSync = true;
485     EXPECT_TRUE(storemetaData1 == storemetaData2);
486 }
487 
488 /**
489  * @tc.name: StoreMetaData
490  * @tc.desc:
491  * @tc.type: FUNC
492  * @tc.require:
493  * @tc.author: SQL
494  */
495 HWTEST_F(ServiceMetaDataTest, StoreMetaData007, TestSize.Level1)
496 {
497     StoreMetaData storemetaData1("100", "appid", "test_store");
498     StoreMetaData storemetaData2("100", "appid", "test_store");
499     StoreMetaData storemetaData3("10", "appid1", "storeid");
500     EXPECT_TRUE(storemetaData1 != storemetaData3);
501     EXPECT_FALSE(storemetaData1 != storemetaData2);
502 
503     storemetaData1.isAutoSync = true;
504     EXPECT_TRUE(storemetaData1 != storemetaData2);
505     storemetaData2.isAutoSync = true;
506     EXPECT_FALSE(storemetaData1 != storemetaData2);
507 
508     storemetaData1.isBackup = true;
509     EXPECT_TRUE(storemetaData1 != storemetaData2);
510     storemetaData2.isBackup = true;
511     EXPECT_FALSE(storemetaData1 != storemetaData2);
512 
513     storemetaData1.isDirty = true;
514     EXPECT_TRUE(storemetaData1 != storemetaData2);
515     storemetaData2.isDirty = true;
516     EXPECT_FALSE(storemetaData1 != storemetaData2);
517 
518     storemetaData1.isEncrypt = true;
519     EXPECT_TRUE(storemetaData1 != storemetaData2);
520     storemetaData2.isEncrypt = true;
521     EXPECT_FALSE(storemetaData1 != storemetaData2);
522 
523     storemetaData1.isSearchable = true;
524     EXPECT_TRUE(storemetaData1 != storemetaData2);
525     storemetaData2.isSearchable = true;
526     EXPECT_FALSE(storemetaData1 != storemetaData2);
527 
528     storemetaData1.isNeedCompress = true;
529     EXPECT_TRUE(storemetaData1 != storemetaData2);
530     storemetaData2.isNeedCompress = true;
531     EXPECT_FALSE(storemetaData1 != storemetaData2);
532 
533     storemetaData1.enableCloud = true;
534     EXPECT_TRUE(storemetaData1 != storemetaData2);
535     storemetaData2.enableCloud = true;
536     EXPECT_FALSE(storemetaData1 != storemetaData2);
537 
538     storemetaData1.cloudAutoSync = true;
539     EXPECT_TRUE(storemetaData1 != storemetaData2);
540     storemetaData2.cloudAutoSync = true;
541     EXPECT_FALSE(storemetaData1 != storemetaData2);
542 }
543 
544 /**
545  * @tc.name: StoreMetaData
546  * @tc.desc:
547  * @tc.type: FUNC
548  * @tc.require:
549  * @tc.author: MY
550  */
551 HWTEST_F(ServiceMetaDataTest, StoreMetaData008, TestSize.Level1)
552 {
553     StoreMetaData storeMetaData("100", "appid", "test_store");
554     storeMetaData.instanceId = 1;
555     storeMetaData.dataDir = "008_dataDir";
556     storeMetaData.deviceId = "008_uuid";
557     storeMetaData.bundleName = "008_bundleName";
558 
559     std::string key = "KvStoreMetaDataLocal###008_uuid###100###default###008_bundleName###test_store###1";
560     EXPECT_EQ(storeMetaData.GetKeyLocalWithoutPath(), key);
561 }
562 
563 /**
564  * @tc.name: StoreMetaData
565  * @tc.desc:
566  * @tc.type: FUNC
567  * @tc.require:
568  * @tc.author: MY
569  */
570 HWTEST_F(ServiceMetaDataTest, StoreMetaData009, TestSize.Level1)
571 {
572     StoreMetaData storeMetaData("100", "appid", "test_store");
573     storeMetaData.instanceId = 1;
574     storeMetaData.dataDir = "009_dataDir";
575     storeMetaData.deviceId = "009_uuid";
576     storeMetaData.bundleName = "009_bundleName";
577 
578     std::string key = "StoreDfxInfo###009_uuid###100###default###009_bundleName###test_store###1###";
579     EXPECT_EQ(storeMetaData.GetDfxInfoKeyWithoutPath(), key);
580 }
581 
582 /**
583  * @tc.name: GetStoreInfo
584  * @tc.desc: test StoreMetaData GetStoreInfo function
585  * @tc.type: FUNC
586  * @tc.require:
587  * @tc.author: SQL
588  */
589 HWTEST_F(ServiceMetaDataTest, GetStoreInfo, TestSize.Level1)
590 {
591     StoreMetaData storeMetaData("100", "appid", "test_store");
592     storeMetaData.version = TEST_CURRENT_VERSION;
593     storeMetaData.instanceId = 1;
594 
595     auto result = storeMetaData.GetStoreInfo();
596     EXPECT_EQ(result.instanceId, storeMetaData.instanceId);
597     EXPECT_EQ(result.bundleName, storeMetaData.bundleName);
598     EXPECT_EQ(result.storeName, storeMetaData.storeId);
599 }
600 
601 /**
602  * @tc.name: StrategyMeta001
603  * @tc.desc:
604  * @tc.type: FUNC
605  * @tc.require:
606  * @tc.author: SQL
607  */
608 HWTEST_F(ServiceMetaDataTest, StrategyMeta001, TestSize.Level1)
609 {
610     auto deviceId = "deviceId";
611     StrategyMeta strategyMeta(deviceId, "100", "ohos.test.demo", "test_store");
612     std::vector<std::string> local = { "local1" };
613     std::vector<std::string> remote = { "remote1" };
614     strategyMeta.capabilityRange.localLabel = local;
615     strategyMeta.capabilityRange.remoteLabel = remote;
616     strategyMeta.capabilityEnabled = true;
617     auto result = strategyMeta.IsEffect();
618     EXPECT_TRUE(result);
619     StrategyMeta strategyMetaData(deviceId, "200", "ohos.test.test", "test_stores");
620 
621     std::string key = strategyMeta.GetKey();
622     EXPECT_EQ(key, "StrategyMetaData###deviceId###100###default###ohos.test.demo###test_store");
623     std::initializer_list<std::string> fields = { deviceId, "100", "default", "ohos.test.demo", "test_store" };
624     std::string prefix = strategyMeta.GetPrefix(fields);
625     EXPECT_EQ(prefix, "StrategyMetaData###deviceId###100###default###ohos.test.demo###test_store");
626 
627     result = MetaDataManager::GetInstance().SaveMeta(key, strategyMeta, true);
628     EXPECT_TRUE(result);
629     result = MetaDataManager::GetInstance().LoadMeta(key, strategyMetaData, true);
630     EXPECT_TRUE(result);
631     EXPECT_EQ(strategyMeta.GetKey(), strategyMetaData.GetKey());
632     EXPECT_EQ(strategyMeta.GetPrefix(fields), strategyMetaData.GetPrefix(fields));
633 
634     result = MetaDataManager::GetInstance().DelMeta(key, true);
635     EXPECT_TRUE(result);
636 
637     result = MetaDataManager::GetInstance().SaveMeta(key, strategyMeta);
638     EXPECT_TRUE(result);
639     result = MetaDataManager::GetInstance().LoadMeta(key, strategyMetaData);
640     EXPECT_TRUE(result);
641     EXPECT_EQ(strategyMeta.GetKey(), strategyMetaData.GetKey());
642     EXPECT_EQ(strategyMeta.GetPrefix(fields), strategyMetaData.GetPrefix(fields));
643 
644     result = MetaDataManager::GetInstance().DelMeta(key);
645     EXPECT_TRUE(result);
646 }
647 
648 /**
649  * @tc.name: StrategyMeta
650  * @tc.desc:
651  * @tc.type: FUNC
652  * @tc.require:
653  * @tc.author: SQL
654  */
655 HWTEST_F(ServiceMetaDataTest, StrategyMeta002, TestSize.Level1)
656 {
657     auto deviceId = "deviceId";
658     StrategyMeta strategyMeta(deviceId, "100", "ohos.test.demo", "test_store");
659     std::vector<std::string> local = { "local1" };
660     std::vector<std::string> remote = { "remote1" };
661     strategyMeta.capabilityRange.localLabel = local;
662     strategyMeta.capabilityRange.remoteLabel = remote;
663     strategyMeta.capabilityEnabled = true;
664     auto result = strategyMeta.IsEffect();
665     EXPECT_TRUE(result);
666     strategyMeta.instanceId = 1;
667     StrategyMeta strategyMetaData(deviceId, "200", "ohos.test.test", "test_stores");
668 
669     std::string key = strategyMeta.GetKey();
670     EXPECT_EQ(key, "StrategyMetaData###deviceId###100###default###ohos.test.demo###test_store###1");
671 
672     result = MetaDataManager::GetInstance().SaveMeta(key, strategyMeta, true);
673     EXPECT_TRUE(result);
674     result = MetaDataManager::GetInstance().LoadMeta(key, strategyMetaData, true);
675     EXPECT_TRUE(result);
676     EXPECT_EQ(strategyMeta.GetKey(), strategyMetaData.GetKey());
677     result = MetaDataManager::GetInstance().DelMeta(key, true);
678     EXPECT_TRUE(result);
679 
680     result = MetaDataManager::GetInstance().SaveMeta(key, strategyMeta);
681     EXPECT_TRUE(result);
682     result = MetaDataManager::GetInstance().LoadMeta(key, strategyMetaData);
683     EXPECT_TRUE(result);
684     EXPECT_EQ(strategyMeta.GetKey(), strategyMetaData.GetKey());
685     result = MetaDataManager::GetInstance().DelMeta(key);
686     EXPECT_TRUE(result);
687 }
688 
689 /**
690  * @tc.name: MetaData
691  * @tc.desc:
692  * @tc.type: FUNC
693  * @tc.require:
694  * @tc.author: SQL
695  */
696 HWTEST_F(ServiceMetaDataTest, MetaData, TestSize.Level1)
697 {
698     StoreMetaData storeMetaData("100", "appid", "test_store");
699     storeMetaData.dataDir = "testDir1";
700     SecretKeyMetaData secretKeyMetaData;
701     MetaData metaData;
702     MetaData metaDataLoad;
703     metaData.storeMetaData = storeMetaData;
704     metaData.secretKeyMetaData = secretKeyMetaData;
705     metaData.storeType = 1;
706     std::initializer_list<std::string> fields = { "time", "skey" };
707     std::string key = metaData.storeMetaData.GetKey();
708     std::string secretkey = metaData.secretKeyMetaData.GetKey(fields);
709 
710     auto result = MetaDataManager::GetInstance().SaveMeta(key, metaData, true);
711     EXPECT_TRUE(result);
712     result = MetaDataManager::GetInstance().LoadMeta(key, metaDataLoad, true);
713     EXPECT_TRUE(result);
714     EXPECT_EQ(key, metaDataLoad.storeMetaData.GetKey());
715     EXPECT_EQ(secretkey, metaDataLoad.secretKeyMetaData.GetKey(fields));
716     result = MetaDataManager::GetInstance().DelMeta(key, true);
717     EXPECT_TRUE(result);
718 
719     result = MetaDataManager::GetInstance().SaveMeta(key, metaData);
720     EXPECT_TRUE(result);
721     result = MetaDataManager::GetInstance().LoadMeta(key, metaDataLoad);
722     EXPECT_TRUE(result);
723     EXPECT_EQ(key, metaDataLoad.storeMetaData.GetKey());
724     EXPECT_EQ(secretkey, metaDataLoad.secretKeyMetaData.GetKey(fields));
725     result = MetaDataManager::GetInstance().DelMeta(key);
726     EXPECT_TRUE(result);
727 }
728 
729 /**
730  * @tc.name: CapMetaData
731  * @tc.desc: test CapMetaData function
732  * @tc.type: FUNC
733  * @tc.require:
734  * @tc.author: SQL
735  */
736 HWTEST_F(ServiceMetaDataTest, CapMetaData, TestSize.Level1)
737 {
738     CapMetaData capMetaData;
739     capMetaData.version = CapMetaData::CURRENT_VERSION;
740     Serializable::json node1;
741     capMetaData.Marshal(node1);
742     EXPECT_EQ(node1["version"], CapMetaData::CURRENT_VERSION);
743 
744     CapMetaData capMeta;
745     capMeta.Unmarshal(node1);
746     EXPECT_EQ(capMeta.version, CapMetaData::CURRENT_VERSION);
747 
748     CapMetaRow capMetaRow;
749     auto key = capMetaRow.GetKeyFor("PEER_DEVICE_ID");
750     std::string str = "CapabilityMeta###PEER_DEVICE_ID";
751     std::vector<uint8_t> testKey = { str.begin(), str.end() };
752     EXPECT_EQ(key, testKey);
753 }
754 
755 /**
756  * @tc.name: UserMetaData
757  * @tc.desc: test UserMetaData function
758  * @tc.type: FUNC
759  * @tc.require:
760  * @tc.author: SQL
761  */
762 HWTEST_F(ServiceMetaDataTest, UserMetaData, TestSize.Level1)
763 {
764     UserMetaData userMetaData;
765     userMetaData.deviceId = "PEER_DEVICE_ID";
766 
767     UserStatus userStatus;
768     userStatus.isActive = true;
769     userStatus.id = USER_ID1;
770     userMetaData.users = { userStatus };
771     userStatus.id = USER_ID2;
772     userMetaData.users.emplace_back(userStatus);
773 
774     Serializable::json node1;
775     userMetaData.Marshal(node1);
776     EXPECT_EQ(node1["deviceId"], "PEER_DEVICE_ID");
777 
778     UserMetaData userMeta;
779     userMeta.Unmarshal(node1);
780     EXPECT_EQ(userMeta.deviceId, "PEER_DEVICE_ID");
781 
782     Serializable::json node2;
783     userStatus.Marshal(node2);
784     EXPECT_EQ(node2["isActive"], true);
785     EXPECT_EQ(node2["id"], USER_ID2);
786 
787     UserStatus userUnmarshal;
788     userUnmarshal.Unmarshal(node2);
789     EXPECT_EQ(userUnmarshal.isActive, true);
790     EXPECT_EQ(userUnmarshal.id, USER_ID2);
791 
792     UserMetaRow userMetaRow;
793     auto key = userMetaRow.GetKeyFor(userMetaData.deviceId);
794     EXPECT_EQ(key, "UserMeta###PEER_DEVICE_ID");
795 }
796 
797 /**
798  * @tc.name: CapabilityRange
799  * @tc.desc: test CapabilityRange function
800  * @tc.type: FUNC
801  * @tc.require:
802  * @tc.author: SQL
803  */
804 HWTEST_F(ServiceMetaDataTest, CapabilityRange, TestSize.Level1)
805 {
806     CapabilityRange capabilityRange;
807     std::vector<std::string> local = { "local1" };
808     std::vector<std::string> remote = { "remote1" };
809     capabilityRange.localLabel = local;
810     capabilityRange.remoteLabel = remote;
811     Serializable::json node1;
812     capabilityRange.Marshal(node1);
813     EXPECT_EQ(node1["localLabel"], local);
814     EXPECT_EQ(node1["remoteLabel"], remote);
815 
816     CapabilityRange capRange;
817     capRange.Unmarshal(node1);
818     EXPECT_EQ(capRange.localLabel, local);
819     EXPECT_EQ(capRange.remoteLabel, remote);
820 }
821 
822 /**
823  * @tc.name: MatrixMetaData
824  * @tc.desc: test MatrixMetaData operator!= function
825  * @tc.type: FUNC
826  * @tc.require:
827  * @tc.author: nhj
828  */
829 HWTEST_F(ServiceMetaDataTest, MatrixMetaData, TestSize.Level1)
830 {
831     MatrixMetaData matrixMetaData1;
832     matrixMetaData1.version = 0;
833     matrixMetaData1.deviceId = "PEER_DEVICE_ID";
834 
835     MatrixMetaData matrixMetaData2;
836     matrixMetaData2.version = 0;
837     matrixMetaData2.deviceId = "PEER_DEVICE_ID";
838 
839     MatrixMetaData matrixMetaData3;
840     matrixMetaData3.version = 1;
841     matrixMetaData3.deviceId = "DEVICE_ID";
842     EXPECT_TRUE(matrixMetaData1 != matrixMetaData3);
843     EXPECT_FALSE(matrixMetaData1 != matrixMetaData2);
844 
845     std::string key = matrixMetaData3.GetConsistentKey();
846     EXPECT_EQ(key, "MatrixMeta###DEVICE_ID###Consistent");
847 }
848 
849 /**
850  * @tc.name: DeviceMetaData
851  * @tc.desc: test DeviceMetaData function
852  * @tc.type: FUNC
853  * @tc.require:
854  * @tc.author: yl
855  */
856 HWTEST_F(ServiceMetaDataTest, DeviceMetaData, TestSize.Level1)
857 {
858     DeviceMetaData  metaData;
859     std::string newUuid = "newuuid";
860     metaData.newUuid = newUuid;
861     Serializable::json node1;
862     metaData.Marshal(node1);
863     EXPECT_EQ(node1["newUuid"], newUuid);
864 
865     DeviceMetaData newMetaData;
866     newMetaData.Unmarshal(node1);
867     EXPECT_EQ(newMetaData.newUuid, newUuid);
868 }
869 
870 /**
871 * @tc.name: InitMeta
872 * @tc.desc: test Init TestMeta
873 * @tc.type: FUNC
874 * @tc.require:
875 * @tc.author: yl
876 */
877 HWTEST_F(ServiceMetaDataTest, InitTestMeta, TestSize.Level1)
878 {
879     StoreMetaData oldMeta;
880     oldMeta.deviceId = "mockOldUuid";
881     oldMeta.user = "200";
882     oldMeta.bundleName = "test_appid_001";
883     oldMeta.storeId = "test_storeid_001";
884     oldMeta.isEncrypt = true;
885     oldMeta.dataDir = "testDir2";
886     bool isSuccess = MetaDataManager::GetInstance().SaveMeta(oldMeta.GetKey(), oldMeta, true);
887     EXPECT_TRUE(isSuccess);
888     StoreMetaDataLocal metaDataLocal;
889     isSuccess = MetaDataManager::GetInstance().SaveMeta(oldMeta.GetKeyLocal(), metaDataLocal, true);
890     EXPECT_TRUE(isSuccess);
891     SwitchesMetaData switchesMetaData;
892     isSuccess = MetaDataManager::GetInstance().SaveMeta(SwitchesMetaData::GetPrefix({"mockOldUuid"}),
893         switchesMetaData, true);
894     EXPECT_TRUE(isSuccess);
895     AutoLaunchMetaData autoLaunchMetaData;
896     MetaDataManager::GetInstance().SaveMeta(AutoLaunchMetaData::GetPrefix({ oldMeta.deviceId, oldMeta.user,
897         "default", oldMeta.bundleName, "" }), autoLaunchMetaData, true);
898     EXPECT_TRUE(isSuccess);
899     MatrixMetaData matrixMeta0;
900     isSuccess = MetaDataManager::GetInstance().SaveMeta(MatrixMetaData::GetPrefix({"mockOldUuid"}), matrixMeta0, true);
901     EXPECT_TRUE(isSuccess);
902 
903     isSuccess = MetaDataManager::GetInstance().SaveMeta(oldMeta.GetKeyWithoutPath(), oldMeta);
904     EXPECT_TRUE(isSuccess);
905     MatrixMetaData matrixMeta;
906     isSuccess = MetaDataManager::GetInstance().SaveMeta(MatrixMetaData::GetPrefix({"mockOldUuid"}), matrixMeta);
907     EXPECT_TRUE(isSuccess);
908     UserMetaData userMeta;
909     isSuccess = MetaDataManager::GetInstance().SaveMeta(UserMetaRow::GetKeyFor("mockOldUuid"), userMeta);
910     EXPECT_TRUE(isSuccess);
911     CapMetaData capMetaData;
912     auto capKey = CapMetaRow::GetKeyFor("mockOldUuid");
913     isSuccess = MetaDataManager::GetInstance().SaveMeta(std::string(capKey.begin(), capKey.end()), capMetaData);
914     EXPECT_TRUE(isSuccess);
915     StrategyMeta strategyMeta;
916     isSuccess = MetaDataManager::GetInstance().SaveMeta(oldMeta.GetStrategyKey(), strategyMeta);
917     EXPECT_TRUE(isSuccess);
918 }
919 
920 /**
921 * @tc.name: UpdateStoreMetaData
922 * @tc.desc: test UpdateStoreMetaData function
923 * @tc.type: FUNC
924 * @tc.require:
925 * @tc.author: yl
926 */
927 HWTEST_F(ServiceMetaDataTest, UpdateStoreMetaData, TestSize.Level1)
928 {
929     std::string mockNewUuid = "mockNewUuid";
930     std::string mockOldUuid = "mockOldUuid";
931     StoreMetaData newMeta;
932     newMeta.deviceId = "mockNewUuid";
933     newMeta.user = "200";
934     newMeta.bundleName = "test_appid_001";
935     newMeta.storeId = "test_storeid_001";
936     newMeta.dataDir = "testDir2";
937     KvStoreMetaManager::GetInstance().UpdateStoreMetaData(mockNewUuid, mockOldUuid);
938     bool isSuccess = MetaDataManager::GetInstance().LoadMeta(newMeta.GetKey(), newMeta, true);
939     EXPECT_TRUE(isSuccess);
940     EXPECT_TRUE(newMeta.isNeedUpdateDeviceId);
941     isSuccess = MetaDataManager::GetInstance().LoadMeta(newMeta.GetKeyWithoutPath(), newMeta);
942     EXPECT_TRUE(isSuccess);
943     AutoLaunchMetaData autoLaunchMetaData;
944     isSuccess = MetaDataManager::GetInstance().LoadMeta(AutoLaunchMetaData::GetPrefix({ newMeta.deviceId, newMeta.user,
945         "default", newMeta.bundleName, "" }), autoLaunchMetaData, true);
946     EXPECT_TRUE(isSuccess);
947     StrategyMeta strategyMeta;
948     isSuccess = MetaDataManager::GetInstance().LoadMeta(newMeta.GetStrategyKey(), strategyMeta);
949     EXPECT_TRUE(isSuccess);
950 }
951 
952 /**
953 * @tc.name: UpdateMetaDatas
954 * @tc.desc: test UpdateMetaDatas function
955 * @tc.type: FUNC
956 * @tc.require:
957 * @tc.author: yl
958 */
959 HWTEST_F(ServiceMetaDataTest, UpdateMetaDatas, TestSize.Level1)
960 {
961     std::string mockNewUuid = "mockNewUuid";
962     std::string mockOldUuid = "mockOldUuid";
963     KvStoreMetaManager::GetInstance().UpdateMetaDatas(mockNewUuid, mockOldUuid);
964     MatrixMetaData matrixMeta;
965     bool isSuccess = MetaDataManager::GetInstance().LoadMeta(MatrixMetaData::GetPrefix({ "mockNewUuid" }),
966         matrixMeta, true);
967     EXPECT_TRUE(isSuccess);
968     isSuccess = MetaDataManager::GetInstance().LoadMeta(MatrixMetaData::GetPrefix({ "mockNewUuid" }), matrixMeta);
969     EXPECT_TRUE(isSuccess);
970     UserMetaData userMeta;
971     isSuccess = MetaDataManager::GetInstance().LoadMeta(MatrixMetaData::GetPrefix({ "mockNewUuid" }), userMeta);
972     EXPECT_TRUE(isSuccess);
973     CapMetaData capMetaData;
974     auto capKey = CapMetaRow::GetKeyFor("mockNewUuid");
975     isSuccess = MetaDataManager::GetInstance().LoadMeta(std::string(capKey.begin(), capKey.end()), capMetaData);
976     EXPECT_TRUE(isSuccess);
977     SwitchesMetaData switchesMetaData;
978     isSuccess = MetaDataManager::GetInstance().LoadMeta(SwitchesMetaData::GetPrefix({ "mockNewUuid" }),
979         switchesMetaData, true);
980     EXPECT_TRUE(isSuccess);
981 }
982 
983 /**
984 * @tc.name: DelInitTestMeta
985 * @tc.desc: test Del TestMeta
986 * @tc.type: FUNC
987 * @tc.require:
988 * @tc.author: yl
989 */
990 HWTEST_F(ServiceMetaDataTest, DelTestMeta, TestSize.Level1)
991 {
992     StoreMetaData newMeta;
993     newMeta.deviceId = "mockNewUuid";
994     newMeta.user = "200";
995     newMeta.bundleName = "test_appid_001";
996     newMeta.storeId = "test_storeid_001";
997     newMeta.dataDir = "testDir2";
998     bool isSuccess = MetaDataManager::GetInstance().DelMeta(newMeta.GetKey(), true);
999     EXPECT_TRUE(isSuccess);
1000     isSuccess = MetaDataManager::GetInstance().DelMeta(newMeta.GetKeyLocal(), true);
1001     EXPECT_TRUE(isSuccess);
1002     isSuccess = MetaDataManager::GetInstance().DelMeta(SwitchesMetaData::GetPrefix({ "mockNewUuid" }), true);
1003     EXPECT_TRUE(isSuccess);
1004     MetaDataManager::GetInstance().DelMeta(AutoLaunchMetaData::GetPrefix({ "mockNewUuid", newMeta.user,
1005         "default", newMeta.bundleName, "" }), true);
1006     EXPECT_TRUE(isSuccess);
1007     isSuccess = MetaDataManager::GetInstance().DelMeta(MatrixMetaData::GetPrefix({ "mockNewUuid" }), true);
1008     EXPECT_TRUE(isSuccess);
1009 
1010     isSuccess = MetaDataManager::GetInstance().DelMeta(newMeta.GetKeyWithoutPath());
1011     EXPECT_TRUE(isSuccess);
1012     isSuccess = MetaDataManager::GetInstance().DelMeta(MatrixMetaData::GetPrefix({"mockNewUuid"}));
1013     EXPECT_TRUE(isSuccess);
1014     isSuccess = MetaDataManager::GetInstance().DelMeta(UserMetaRow::GetKeyFor("mockNewUuid"));
1015     EXPECT_TRUE(isSuccess);
1016     auto capKey = CapMetaRow::GetKeyFor("mockNewUuid");
1017     isSuccess = MetaDataManager::GetInstance().DelMeta(std::string(capKey.begin(), capKey.end()));
1018     EXPECT_TRUE(isSuccess);
1019     isSuccess = MetaDataManager::GetInstance().DelMeta(newMeta.GetStrategyKey());
1020     EXPECT_TRUE(isSuccess);
1021 }
1022 
1023 /**
1024 * @tc.name: GetKeyTest
1025 * @tc.desc: GetKey
1026 * @tc.type: FUNC
1027 * @tc.require:
1028 * @tc.author: yl
1029 */
1030 HWTEST_F(ServiceMetaDataTest, GetKey, TestSize.Level1)
1031 {
1032     DeviceMetaData metaData;
1033     std::string expectedPrefix = "DeviceMeta";
1034     std::string prefix = metaData.GetKey();
1035     EXPECT_EQ(prefix, expectedPrefix);
1036 }
1037 
1038 /**
1039 * @tc.name: ObjectUserMetaDataGetKey
1040 * @tc.desc: ObjectUserMetaDataGetKey
1041 * @tc.type: FUNC
1042 */
1043 HWTEST_F(ServiceMetaDataTest, ObjectUserMetaDataGetKey, TestSize.Level1)
1044 {
1045     ObjectUserMetaData metaData;
1046     std::string expectedPrefix = "ObjectUserMetaData";
1047     std::string prefix = metaData.GetKey();
1048     EXPECT_EQ(prefix, expectedPrefix);
1049 }
1050 } // namespace OHOS::Test