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 "distributeddb_schema_test_tools.h"
18
19 using namespace std;
20 using namespace testing;
21 #if defined TESTCASES_USING_GTEST_EXT
22 using namespace testing::ext;
23 #endif
24 using namespace DistributedDB;
25 using namespace DistributedDBDataGenerator;
26
27 namespace DistributeddbNbSchemaUpgradeDb {
28 KvStoreNbDelegate *g_nbSchemaUpgradeDelegate = nullptr;
29 KvStoreDelegateManager *g_manager = nullptr;
30 class DistributeddbNbSchemaUpgradeTest : public testing::Test {
31 public:
32 void SetUp();
33 void TearDown();
34 private:
35 };
36
SetUp(void)37 void DistributeddbNbSchemaUpgradeTest::SetUp(void)
38 {
39 RemoveDir(DistributedDBConstant::NB_DIRECTOR);
40
41 UnitTest *test = UnitTest::GetInstance();
42 ASSERT_NE(test, nullptr);
43 const TestInfo *testinfo = test->current_test_info();
44 ASSERT_NE(testinfo, nullptr);
45 string testCaseName = string(testinfo->name());
46 MST_LOG("[SetUp] test case %s is start to run", testCaseName.c_str());
47 }
48
TearDown(void)49 void DistributeddbNbSchemaUpgradeTest::TearDown(void)
50 {
51 MST_LOG("TearDownTestCase after case.");
52 RemoveDir(DistributedDBConstant::NB_DIRECTOR);
53 }
54
55 /**
56 * @tc.name: SchemaNotNullDefault 001
57 * @tc.desc: Verify that schema db has the field that with not-null and default Attribute
58 * can normally insert the value has not null field value
59 * @tc.type: FUNC
60 * @tc.require: SR000EUVPV
61 * @tc.author: fengxiaoyun
62 */
63 HWTEST_F(DistributeddbNbSchemaUpgradeTest, SchemaNotNullDefault001, TestSize.Level0)
64 {
65 /**
66 * @tc.steps: step1. create db with valid SCHEMA_DEFINE_NNULL_DEFAULT, strict mode and version 1.0.
67 * @tc.expected: step1. create successfully.
68 */
69 Option option = g_option;
70 option.isMemoryDb = false;
71 option.schema = SpliceToSchema(VALID_VERSION_1, VALID_MODE_1, SCHEMA_DEFINE_NNULL_DEFAULT, VALID_INDEX_1);
72 g_nbSchemaUpgradeDelegate = DistributedDBNbTestTools::GetNbDelegateSuccess(g_manager, g_dbParameter1, option);
73 ASSERT_TRUE(g_manager != nullptr && g_nbSchemaUpgradeDelegate != nullptr);
74
75 /**
76 * @tc.steps: step2. insert valid value to DB.
77 * @tc.expected: step2. insert succeed.
78 */
79 string stringValue = "{\"field1\":\"schema\",\"field2\":{\"field3\":123,\"field4\":false,"
80 "\"field1\":{\"field5\":123567,\"field2\":{\"field6\":-123.456}}}}";
81 Value value(stringValue.begin(), stringValue.end());
82 EXPECT_EQ(DistributedDBNbTestTools::Put(*g_nbSchemaUpgradeDelegate, KEY_1, value), OK);
83
84 /**
85 * @tc.steps: step3. check the data in db.
86 * @tc.expected: step3. can find value in db.
87 */
88 Query query = Query::Select().EqualTo("$.field1", "schema");
89 vector<Entry> entriesGot;
90 vector<Entry> entries = {{KEY_1, value}};
91 EXPECT_EQ(g_nbSchemaUpgradeDelegate->GetEntries(query, entriesGot), OK);
92 EXPECT_TRUE(CompareEntriesVector(entriesGot, entries));
93
94 EXPECT_TRUE(EndCaseDeleteDB(g_manager, g_nbSchemaUpgradeDelegate, STORE_ID_1, option.isMemoryDb));
95 }
96
InsertFieldWithNullValue(KvStoreNbDelegate * & delegate,DBStatus expectStatus)97 void InsertFieldWithNullValue(KvStoreNbDelegate *&delegate, DBStatus expectStatus)
98 {
99 /**
100 * @tc.steps: step2. insert invalid value1 which with null field1 to DB.
101 * @tc.expected: step2. insert failed.
102 */
103 string stringValue1 = "{\"field1\":null,\"field2\":{\"field3\":123,\"field4\":false,"
104 "\"field1\":{\"field5\":123567,\"field2\":{\"field6\":-123.456}}}}";
105 Value value1(stringValue1.begin(), stringValue1.end());
106 EXPECT_EQ(DistributedDBNbTestTools::Put(*delegate, KEY_1, value1), expectStatus);
107 /**
108 * @tc.steps: step3. insert invalid value2 which with null field3 to DB.
109 * @tc.expected: step3. insert failed.
110 */
111 string stringValue2 = "{\"field1\":\"schema\",\"field2\":{\"field3\":null,\"field4\":false,"
112 "\"field1\":{\"field5\":123567,\"field2\":{\"field6\":-123.456}}}}";
113 Value value2(stringValue2.begin(), stringValue2.end());
114 EXPECT_EQ(DistributedDBNbTestTools::Put(*delegate, KEY_2, value2), expectStatus);
115 /**
116 * @tc.steps: step4. insert invalid value3 which with null field4 to DB.
117 * @tc.expected: step4. insert failed.
118 */
119 string stringValue3 = "{\"field1\":\"schema\",\"field2\":{\"field3\":123,\"field4\":null,"
120 "\"field1\":{\"field5\":123567,\"field2\":{\"field6\":-123.456}}}}";
121 Value value3(stringValue3.begin(), stringValue3.end());
122 EXPECT_EQ(DistributedDBNbTestTools::Put(*delegate, KEY_3, value3), expectStatus);
123 /**
124 * @tc.steps: step5. insert invalid value4 which with null field5 to DB.
125 * @tc.expected: step5. insert failed.
126 */
127 string stringValue4 = "{\"field1\":\"schema\",\"field2\":{\"field3\":123,\"field4\":false,"
128 "\"field1\":{\"field5\":null,\"field2\":{\"field6\":-123.456}}}}";
129 Value value4(stringValue4.begin(), stringValue4.end());
130 EXPECT_EQ(DistributedDBNbTestTools::Put(*delegate, KEY_4, value4), expectStatus);
131 /**
132 * @tc.steps: step6. insert invalid value5 which with null field6 to DB.
133 * @tc.expected: step6. insert failed.
134 */
135 string stringValue5 = "{\"field1\":\"schema\",\"field2\":{\"field3\":123,\"field4\":false,"
136 "\"field1\":{\"field5\":123567,\"field2\":{\"field6\":null}}}}";
137 Value value5(stringValue5.begin(), stringValue5.end());
138 EXPECT_EQ(DistributedDBNbTestTools::Put(*delegate, KEY_5, value5), expectStatus);
139 /**
140 * @tc.steps: step7. insert invalid value6 all fields of which with null value to DB.
141 * @tc.expected: step7. insert failed.
142 */
143 string stringValue6 = "{\"field1\":null,\"field2\":{\"field3\":null,\"field4\":null,"
144 "\"field1\":{\"field5\":null,\"field2\":{\"field6\":null}}}}";
145 Value value6(stringValue6.begin(), stringValue6.end());
146 EXPECT_EQ(DistributedDBNbTestTools::Put(*delegate, KEY_6, value6), expectStatus);
147 }
148
149 /**
150 * @tc.name: SchemaNotNullDefault 002
151 * @tc.desc: Verify that schema db has the field that with not-null and default Attribute
152 * can't insert the value field of which is null
153 * @tc.type: FUNC
154 * @tc.require: SR000EUVPV
155 * @tc.author: fengxiaoyun
156 */
157 HWTEST_F(DistributeddbNbSchemaUpgradeTest, SchemaNotNullDefault002, TestSize.Level0)
158 {
159 /**
160 * @tc.steps: step1. create db with valid SCHEMA_DEFINE_NNULL_DEFAULT, strict mode and version 1.0.
161 * @tc.expected: step1. create successfully.
162 */
163 Option option = g_option;
164 option.isMemoryDb = false;
165 option.schema = SpliceToSchema(VALID_VERSION_1, VALID_MODE_1, SCHEMA_DEFINE_NNULL_DEFAULT, VALID_INDEX_1);
166 g_nbSchemaUpgradeDelegate = DistributedDBNbTestTools::GetNbDelegateSuccess(g_manager, g_dbParameter1, option);
167 ASSERT_TRUE(g_manager != nullptr && g_nbSchemaUpgradeDelegate != nullptr);
168
169 InsertFieldWithNullValue(g_nbSchemaUpgradeDelegate, CONSTRAIN_VIOLATION);
170
171 /**
172 * @tc.steps: step8. check the data in db.
173 * @tc.expected: step8. can't find any records in db.
174 */
175 vector<Entry> entriesGot;
176 EXPECT_EQ(g_nbSchemaUpgradeDelegate->GetEntries(KEY_EMPTY, entriesGot), NOT_FOUND);
177
178 EXPECT_TRUE(EndCaseDeleteDB(g_manager, g_nbSchemaUpgradeDelegate, STORE_ID_1, option.isMemoryDb));
179 }
180
InsertVoidFieldSteps(KvStoreNbDelegate * & delegate,DBStatus expectStatus)181 void InsertVoidFieldSteps(KvStoreNbDelegate *&delegate, DBStatus expectStatus)
182 {
183 /**
184 * @tc.steps: step2. insert valid value1 field1 of which hasn't value to DB.
185 * @tc.expected: step2. result as expectStatus.
186 */
187 string stringValue1 = "{\"field2\":{\"field3\":123,\"field4\":false,"
188 "\"field1\":{\"field5\":123567,\"field2\":{\"field6\":-123.456}}}}";
189 Value value1(stringValue1.begin(), stringValue1.end());
190 EXPECT_EQ(DistributedDBNbTestTools::Put(*delegate, KEY_1, value1), expectStatus);
191 /**
192 * @tc.steps: step3. insert valid value2 field3 of which hasn't value to DB.
193 * @tc.expected: step3. result as expectStatus.
194 */
195 string stringValue2 = "{\"field1\":\"schema\",\"field2\":{\"field4\":false,"
196 "\"field1\":{\"field5\":123567,\"field2\":{\"field6\":-123.456}}}}";
197 Value value2(stringValue2.begin(), stringValue2.end());
198 EXPECT_EQ(DistributedDBNbTestTools::Put(*delegate, KEY_2, value2), expectStatus);
199 /**
200 * @tc.steps: step4. insert valid value3 field4 of which hasn't value to DB.
201 * @tc.expected: step4. result as expectStatus.
202 */
203 string stringValue3 = "{\"field1\":\"schema\",\"field2\":{\"field3\":123,"
204 "\"field1\":{\"field5\":123567,\"field2\":{\"field6\":-123.456}}}}";
205 Value value3(stringValue3.begin(), stringValue3.end());
206 EXPECT_EQ(DistributedDBNbTestTools::Put(*delegate, KEY_3, value3), expectStatus);
207 /**
208 * @tc.steps: step5. insert valid value4 field5 of which hasn't value to DB.
209 * @tc.expected: step5. result as expectStatus.
210 */
211 string stringValue4 = "{\"field1\":\"schema\",\"field2\":{\"field3\":123,\"field4\":false,"
212 "\"field1\":{\"field2\":{\"field6\":-123.456}}}}";
213 Value value4(stringValue4.begin(), stringValue4.end());
214 EXPECT_EQ(DistributedDBNbTestTools::Put(*delegate, KEY_4, value4), expectStatus);
215 /**
216 * @tc.steps: step6. insert valid value5 field6 of which hasn't value to DB.
217 * @tc.expected: step6. result as expectStatus.
218 */
219 string stringValue5 = "{\"field1\":\"schema\",\"field2\":{\"field3\":123,\"field4\":false,"
220 "\"field1\":{\"field5\":123567,\"field2\":{}}}}";
221 Value value5(stringValue5.begin(), stringValue5.end());
222 EXPECT_EQ(DistributedDBNbTestTools::Put(*delegate, KEY_5, value5), expectStatus);
223 /**
224 * @tc.steps: step7. insert valid value6 field1, field4, field6 of which hasn't value to DB.
225 * @tc.expected: step7. result as expectStatus.
226 */
227 string stringValue6 = "{\"field2\":{\"field3\":123,\"field1\":{\"field5\":123567,\"field2\":{}}}}";
228 Value value6(stringValue6.begin(), stringValue6.end());
229 EXPECT_EQ(DistributedDBNbTestTools::Put(*delegate, KEY_6, value6), expectStatus);
230 /**
231 * @tc.steps: step8. insert valid value7 all fields of which have default values to DB.
232 * @tc.expected: step8. result as expectStatus.
233 */
234 string stringValue7 = "{\"field2\":{\"field1\":{\"field2\":{}}}}";
235 Value value7(stringValue7.begin(), stringValue7.end());
236 EXPECT_EQ(DistributedDBNbTestTools::Put(*delegate, KEY_7, value7), expectStatus);
237 }
238
CheckSchemaVoidFieldDefaultResult()239 void CheckSchemaVoidFieldDefaultResult()
240 {
241 vector<Entry> entriesGot;
242 EXPECT_EQ(g_nbSchemaUpgradeDelegate->GetEntries(KEY_EMPTY, entriesGot), OK);
243 sort(entriesGot.begin(), entriesGot.end(), DistributedTestTools::CompareKey);
244 string stringValue1d(entriesGot[INDEX_ZEROTH].value.begin(), entriesGot[INDEX_ZEROTH].value.end());
245 string stringValue2d(entriesGot[INDEX_FIRST].value.begin(), entriesGot[INDEX_FIRST].value.end());
246 string stringValue3d(entriesGot[INDEX_SECOND].value.begin(), entriesGot[INDEX_SECOND].value.end());
247 string stringValue4d(entriesGot[INDEX_THIRD].value.begin(), entriesGot[INDEX_THIRD].value.end());
248 string stringValue5d(entriesGot[INDEX_FORTH].value.begin(), entriesGot[INDEX_FORTH].value.end());
249 string stringValue6d(entriesGot[INDEX_FIFTH].value.begin(), entriesGot[INDEX_FIFTH].value.end());
250 string stringValue7d(entriesGot[INDEX_SIXTH].value.begin(), entriesGot[INDEX_SIXTH].value.end());
251 EXPECT_NE(stringValue1d.find("\"field1\":\"json\""), std::string::npos);
252 EXPECT_NE(stringValue2d.find("\"field3\":0"), std::string::npos);
253 EXPECT_NE(stringValue3d.find("\"field4\":true"), std::string::npos);
254 EXPECT_NE(stringValue4d.find("\"field5\":2021456"), std::string::npos);
255 EXPECT_NE(stringValue5d.find("\"field6\":2021.2"), std::string::npos);
256 EXPECT_NE(stringValue6d.find("\"field1\":\"json\""), std::string::npos);
257 EXPECT_NE(stringValue6d.find("\"field4\":true"), std::string::npos);
258 EXPECT_NE(stringValue6d.find("\"field6\":2021.2"), std::string::npos);
259 EXPECT_NE(stringValue7d.find("\"field1\":\"json\""), std::string::npos);
260 EXPECT_NE(stringValue7d.find("\"field3\":0"), std::string::npos);
261 EXPECT_NE(stringValue7d.find("\"field4\":true"), std::string::npos);
262 EXPECT_NE(stringValue7d.find("\"field5\":2021456"), std::string::npos);
263 EXPECT_NE(stringValue7d.find("\"field6\":2021.2"), std::string::npos);
264 }
265
266 /**
267 * @tc.name: SchemaNotNullDefault 003
268 * @tc.desc: Verify that schema db has the field that with not-null and default Attribute
269 * can insert the value field of which are not exist
270 * @tc.type: FUNC
271 * @tc.require: SR000EUVPV
272 * @tc.author: fengxiaoyun
273 */
274 HWTEST_F(DistributeddbNbSchemaUpgradeTest, SchemaNotNullDefault003, TestSize.Level0)
275 {
276 /**
277 * @tc.steps: step1. create db with valid SCHEMA_DEFINE_NNULL_DEFAULT, strict mode and version 1.0.
278 * @tc.expected: step1. create successfully.
279 */
280 Option option = g_option;
281 option.isMemoryDb = false;
282 option.schema = SpliceToSchema(VALID_VERSION_1, VALID_MODE_1, SCHEMA_DEFINE_NNULL_DEFAULT, VALID_INDEX_1);
283 g_nbSchemaUpgradeDelegate = DistributedDBNbTestTools::GetNbDelegateSuccess(g_manager, g_dbParameter1, option);
284 ASSERT_TRUE(g_manager != nullptr && g_nbSchemaUpgradeDelegate != nullptr);
285
286 InsertVoidFieldSteps(g_nbSchemaUpgradeDelegate, OK);
287
288 /**
289 * @tc.steps: step9. check the data in db.
290 * @tc.expected: step9. can find all the Entries and all the field which have no value when it inserted
291 * has default value in db.
292 */
293 CheckSchemaVoidFieldDefaultResult();
294
295 EXPECT_TRUE(EndCaseDeleteDB(g_manager, g_nbSchemaUpgradeDelegate, STORE_ID_1, option.isMemoryDb));
296 }
297
298 /**
299 * @tc.name: SchemaNotNullDefault 004
300 * @tc.desc: Verify that schema db has the field that with not-null but no default value Attribute
301 * can normally insert the value has the right value
302 * @tc.type: FUNC
303 * @tc.require: SR000EUVPV
304 * @tc.author: fengxiaoyun
305 */
306 HWTEST_F(DistributeddbNbSchemaUpgradeTest, SchemaNotNullDefault004, TestSize.Level0)
307 {
308 /**
309 * @tc.steps: step1. create db with valid SCHEMA_DEFINE_NNULL, strict mode and version 1.0.
310 * @tc.expected: step1. create successfully.
311 */
312 Option option = g_option;
313 option.isMemoryDb = false;
314 option.schema = SpliceToSchema(VALID_VERSION_1, VALID_MODE_1, SCHEMA_DEFINE_NNULL, VALID_INDEX_1);
315 g_nbSchemaUpgradeDelegate = DistributedDBNbTestTools::GetNbDelegateSuccess(g_manager, g_dbParameter1, option);
316 ASSERT_TRUE(g_manager != nullptr && g_nbSchemaUpgradeDelegate != nullptr);
317
318 /**
319 * @tc.steps: step2. insert valid value to DB.
320 * @tc.expected: step2. insert succeed.
321 */
322 string stringValue = "{\"field1\":\"schema\",\"field2\":{\"field3\":123,\"field4\":false,"
323 "\"field1\":{\"field5\":123567,\"field2\":{\"field6\":-123.456}}}}";
324 Value value(stringValue.begin(), stringValue.end());
325 EXPECT_EQ(DistributedDBNbTestTools::Put(*g_nbSchemaUpgradeDelegate, KEY_1, value), OK);
326
327 /**
328 * @tc.steps: step3. check the data in db.
329 * @tc.expected: step3. can find value in db.
330 */
331 Query query = Query::Select().EqualTo("$.field2.field3", 123); // 123 is the value of field3
332 vector<Entry> entriesGot;
333 vector<Entry> entries = {{KEY_1, value}};
334 EXPECT_EQ(g_nbSchemaUpgradeDelegate->GetEntries(query, entriesGot), OK);
335 EXPECT_TRUE(CompareEntriesVector(entriesGot, entries));
336
337 EXPECT_TRUE(EndCaseDeleteDB(g_manager, g_nbSchemaUpgradeDelegate, STORE_ID_1, option.isMemoryDb));
338 }
339
340 /**
341 * @tc.name: SchemaNotNullDefault 005
342 * @tc.desc: Verify that schema db has the field that with not-null but no default value Attribute
343 * can't insert the value field of which is null
344 * @tc.type: FUNC
345 * @tc.require: SR000EUVPV
346 * @tc.author: fengxiaoyun
347 */
348 HWTEST_F(DistributeddbNbSchemaUpgradeTest, SchemaNotNullDefault005, TestSize.Level0)
349 {
350 /**
351 * @tc.steps: step1. create db with valid SCHEMA_DEFINE_NNULL, strict mode and version 1.0.
352 * @tc.expected: step1. create successfully.
353 */
354 Option option = g_option;
355 option.isMemoryDb = false;
356 option.schema = SpliceToSchema(VALID_VERSION_1, VALID_MODE_1, SCHEMA_DEFINE_NNULL, VALID_INDEX_1);
357 g_nbSchemaUpgradeDelegate = DistributedDBNbTestTools::GetNbDelegateSuccess(g_manager, g_dbParameter1, option);
358 ASSERT_TRUE(g_manager != nullptr && g_nbSchemaUpgradeDelegate != nullptr);
359
360 InsertFieldWithNullValue(g_nbSchemaUpgradeDelegate, CONSTRAIN_VIOLATION);
361
362 /**
363 * @tc.steps: step8. check the data in db.
364 * @tc.expected: step8. can't find any records in db.
365 */
366 vector<Entry> entriesGot;
367 EXPECT_EQ(g_nbSchemaUpgradeDelegate->GetEntries(KEY_EMPTY, entriesGot), NOT_FOUND);
368
369 EXPECT_TRUE(EndCaseDeleteDB(g_manager, g_nbSchemaUpgradeDelegate, STORE_ID_1, option.isMemoryDb));
370 }
371
372 /**
373 * @tc.name: SchemaNotNullDefault 006
374 * @tc.desc: Verify that schema db has the field that with not-null and default Attribute
375 * can insert the value field of which hasn't value
376 * @tc.type: FUNC
377 * @tc.require: SR000EUVPV
378 * @tc.author: fengxiaoyun
379 */
380 HWTEST_F(DistributeddbNbSchemaUpgradeTest, SchemaNotNullDefault006, TestSize.Level0)
381 {
382 /**
383 * @tc.steps: step1. create db with valid SCHEMA_DEFINE_NNULL, strict mode and version 1.0.
384 * @tc.expected: step1. create successfully.
385 */
386 Option option = g_option;
387 option.isMemoryDb = false;
388 option.schema = SpliceToSchema(VALID_VERSION_1, VALID_MODE_1, SCHEMA_DEFINE_NNULL, VALID_INDEX_1);
389 g_nbSchemaUpgradeDelegate = DistributedDBNbTestTools::GetNbDelegateSuccess(g_manager, g_dbParameter1, option);
390 ASSERT_TRUE(g_manager != nullptr && g_nbSchemaUpgradeDelegate != nullptr);
391
392 InsertVoidFieldSteps(g_nbSchemaUpgradeDelegate, CONSTRAIN_VIOLATION);
393
394 /**
395 * @tc.steps: step9. check the data in db.
396 * @tc.expected: step9. can't find any data in db
397 */
398 vector<Entry> entriesGot;
399 EXPECT_TRUE(g_nbSchemaUpgradeDelegate->GetEntries(KEY_EMPTY, entriesGot) == NOT_FOUND);
400
401 EXPECT_TRUE(EndCaseDeleteDB(g_manager, g_nbSchemaUpgradeDelegate, STORE_ID_1, option.isMemoryDb));
402 }
403
404 /**
405 * @tc.name: SchemaNotNullDefault 007
406 * @tc.desc: Verify that schema db has the field that has default value but without not-null Attribute
407 * can normally insert the value has the right value
408 * @tc.type: FUNC
409 * @tc.require: SR000EUVPV
410 * @tc.author: fengxiaoyun
411 */
412 HWTEST_F(DistributeddbNbSchemaUpgradeTest, SchemaNotNullDefault007, TestSize.Level0)
413 {
414 /**
415 * @tc.steps: step1. create db with valid SCHEMA_DEFINE_DEFAULT, strict mode and version 1.0.
416 * @tc.expected: step1. create successfully.
417 */
418 Option option = g_option;
419 option.isMemoryDb = false;
420 option.schema = SpliceToSchema(VALID_VERSION_1, VALID_MODE_1, SCHEMA_DEFINE_DEFAULT, VALID_INDEX_1);
421 g_nbSchemaUpgradeDelegate = DistributedDBNbTestTools::GetNbDelegateSuccess(g_manager, g_dbParameter1, option);
422 ASSERT_TRUE(g_manager != nullptr && g_nbSchemaUpgradeDelegate != nullptr);
423
424 /**
425 * @tc.steps: step2. insert valid value to DB.
426 * @tc.expected: step2. insert succeed.
427 */
428 string stringValue = "{\"field1\":\"schema\",\"field2\":{\"field3\":123,\"field4\":false,"
429 "\"field1\":{\"field5\":123567,\"field2\":{\"field6\":-123.456}}}}";
430 Value value(stringValue.begin(), stringValue.end());
431 EXPECT_EQ(DistributedDBNbTestTools::Put(*g_nbSchemaUpgradeDelegate, KEY_1, value), OK);
432
433 /**
434 * @tc.steps: step3. check the data in db.
435 * @tc.expected: step3. can find value in db.
436 */
437 Query query = Query::Select().EqualTo("$.field2.field4", false);
438 vector<Entry> entriesGot;
439 vector<Entry> entries = {{KEY_1, value}};
440 EXPECT_EQ(g_nbSchemaUpgradeDelegate->GetEntries(query, entriesGot), OK);
441 EXPECT_TRUE(CompareEntriesVector(entriesGot, entries));
442
443 EXPECT_TRUE(EndCaseDeleteDB(g_manager, g_nbSchemaUpgradeDelegate, STORE_ID_1, option.isMemoryDb));
444 }
445
CheckNullFieldSucceed(KvStoreNbDelegate * & delegate)446 void CheckNullFieldSucceed(KvStoreNbDelegate *&delegate)
447 {
448 InsertFieldWithNullValue(g_nbSchemaUpgradeDelegate, OK);
449 /**
450 * @tc.steps: step8. check the data in db.
451 * @tc.expected: step8. can find all the records that insert in db, and the value corresponding field is null.
452 */
453 vector<Entry> entriesGot;
454 EXPECT_EQ(delegate->GetEntries(KEY_EMPTY, entriesGot), OK);
455 sort(entriesGot.begin(), entriesGot.end(), DistributedTestTools::CompareKey);
456 string stringValue1n(entriesGot[INDEX_ZEROTH].value.begin(), entriesGot[INDEX_ZEROTH].value.end());
457 string stringValue2n(entriesGot[INDEX_FIRST].value.begin(), entriesGot[INDEX_FIRST].value.end());
458 string stringValue3n(entriesGot[INDEX_SECOND].value.begin(), entriesGot[INDEX_SECOND].value.end());
459 string stringValue4n(entriesGot[INDEX_THIRD].value.begin(), entriesGot[INDEX_THIRD].value.end());
460 string stringValue5n(entriesGot[INDEX_FORTH].value.begin(), entriesGot[INDEX_FORTH].value.end());
461 string stringValue6n(entriesGot[INDEX_FIFTH].value.begin(), entriesGot[INDEX_FIFTH].value.end());
462 EXPECT_NE(stringValue1n.find("\"field1\":null"), std::string::npos);
463 EXPECT_NE(stringValue2n.find("\"field3\":null"), std::string::npos);
464 EXPECT_NE(stringValue3n.find("\"field4\":null"), std::string::npos);
465 EXPECT_NE(stringValue4n.find("\"field5\":null"), std::string::npos);
466 EXPECT_NE(stringValue5n.find("\"field6\":null"), std::string::npos);
467 EXPECT_NE(stringValue6n.find("\"field1\":null"), std::string::npos);
468 EXPECT_NE(stringValue6n.find("\"field3\":null"), std::string::npos);
469 EXPECT_NE(stringValue6n.find("\"field4\":null"), std::string::npos);
470 EXPECT_NE(stringValue6n.find("\"field5\":null"), std::string::npos);
471 EXPECT_NE(stringValue6n.find("\"field6\":null"), std::string::npos);
472 }
473
474 /**
475 * @tc.name: SchemaNotNullDefault 008
476 * @tc.desc: Verify that schema db has the field that has default value but without not-null Attribute
477 * can also insert the value field of which is null
478 * @tc.type: FUNC
479 * @tc.require: SR000EUVPV
480 * @tc.author: fengxiaoyun
481 */
482 HWTEST_F(DistributeddbNbSchemaUpgradeTest, SchemaNotNullDefault008, TestSize.Level0)
483 {
484 /**
485 * @tc.steps: step1. create db with valid SCHEMA_DEFINE_DEFAULT, strict mode and version 1.0.
486 * @tc.expected: step1. create successfully.
487 */
488 Option option = g_option;
489 option.isMemoryDb = false;
490 option.schema = SpliceToSchema(VALID_VERSION_1, VALID_MODE_1, SCHEMA_DEFINE_DEFAULT, VALID_INDEX_1);
491 g_nbSchemaUpgradeDelegate = DistributedDBNbTestTools::GetNbDelegateSuccess(g_manager, g_dbParameter1, option);
492 ASSERT_TRUE(g_manager != nullptr && g_nbSchemaUpgradeDelegate != nullptr);
493
494 CheckNullFieldSucceed(g_nbSchemaUpgradeDelegate);
495
496 EXPECT_TRUE(EndCaseDeleteDB(g_manager, g_nbSchemaUpgradeDelegate, STORE_ID_1, option.isMemoryDb));
497 }
498
499 /**
500 * @tc.name: SchemaNotNullDefault 009
501 * @tc.desc: Verify that schema db has the field that has default value but without not-null Attribute
502 * can insert the value field of which hasn't value
503 * @tc.type: FUNC
504 * @tc.require: SR000EUVPV
505 * @tc.author: fengxiaoyun
506 */
507 HWTEST_F(DistributeddbNbSchemaUpgradeTest, SchemaNotNullDefault009, TestSize.Level0)
508 {
509 /**
510 * @tc.steps: step1. create db with valid SCHEMA_DEFINE_DEFAULT, strict mode and version 1.0.
511 * @tc.expected: step1. create successfully.
512 */
513 Option option = g_option;
514 option.isMemoryDb = false;
515 option.schema = SpliceToSchema(VALID_VERSION_1, VALID_MODE_1, SCHEMA_DEFINE_DEFAULT, VALID_INDEX_1);
516 g_nbSchemaUpgradeDelegate = DistributedDBNbTestTools::GetNbDelegateSuccess(g_manager, g_dbParameter1, option);
517 ASSERT_TRUE(g_manager != nullptr && g_nbSchemaUpgradeDelegate != nullptr);
518
519 InsertVoidFieldSteps(g_nbSchemaUpgradeDelegate, OK);
520
521 /**
522 * @tc.steps: step9. check the data in db.
523 * @tc.expected: step9. can find all the Entries and all the field which have no value when it inserted
524 * has default value in db.
525 */
526 CheckSchemaVoidFieldDefaultResult();
527
528 EXPECT_TRUE(EndCaseDeleteDB(g_manager, g_nbSchemaUpgradeDelegate, STORE_ID_1, option.isMemoryDb));
529 }
530
531 /**
532 * @tc.name: SchemaNotNullDefault 010
533 * @tc.desc: Verify that schema db has the field that hasn't default value and not-null Attribute
534 * can normally insert the value has the right value
535 * @tc.type: FUNC
536 * @tc.require: SR000EUVPV
537 * @tc.author: fengxiaoyun
538 */
539 HWTEST_F(DistributeddbNbSchemaUpgradeTest, SchemaNotNullDefault010, TestSize.Level0)
540 {
541 /**
542 * @tc.steps: step1. create db with valid SCHEMA_DEFINE_NON_ATTRI, strict mode and version 1.0.
543 * @tc.expected: step1. create successfully.
544 */
545 Option option = g_option;
546 option.isMemoryDb = false;
547 option.schema = SpliceToSchema(VALID_VERSION_1, VALID_MODE_1, SCHEMA_DEFINE_NON_ATTRI, VALID_INDEX_1);
548 g_nbSchemaUpgradeDelegate = DistributedDBNbTestTools::GetNbDelegateSuccess(g_manager, g_dbParameter1, option);
549 ASSERT_TRUE(g_manager != nullptr && g_nbSchemaUpgradeDelegate != nullptr);
550
551 /**
552 * @tc.steps: step2. insert valid value to DB.
553 * @tc.expected: step2. insert succeed.
554 */
555 string stringValue = "{\"field1\":\"schema\",\"field2\":{\"field3\":123,\"field4\":false,"
556 "\"field1\":{\"field5\":123567,\"field2\":{\"field6\":-123.456}}}}";
557 Value value(stringValue.begin(), stringValue.end());
558 EXPECT_EQ(DistributedDBNbTestTools::Put(*g_nbSchemaUpgradeDelegate, KEY_1, value), OK);
559
560 /**
561 * @tc.steps: step3. check the data in db.
562 * @tc.expected: step3. can find value in db.
563 */
564 Query query = Query::Select().EqualTo("$.field2.field1.field5", 123567); // 123567 is the value of field5
565 vector<Entry> entriesGot;
566 vector<Entry> entries = {{KEY_1, value}};
567 EXPECT_EQ(g_nbSchemaUpgradeDelegate->GetEntries(query, entriesGot), OK);
568 EXPECT_TRUE(CompareEntriesVector(entriesGot, entries));
569
570 EXPECT_TRUE(EndCaseDeleteDB(g_manager, g_nbSchemaUpgradeDelegate, STORE_ID_1, option.isMemoryDb));
571 }
572
573 /**
574 * @tc.name: SchemaNotNullDefault 011
575 * @tc.desc: Verify that schema db has the field that hasn't default value and not-null Attribute
576 * can also insert the value field of which is null
577 * @tc.type: FUNC
578 * @tc.require: SR000EUVPV
579 * @tc.author: fengxiaoyun
580 */
581 HWTEST_F(DistributeddbNbSchemaUpgradeTest, SchemaNotNullDefault011, TestSize.Level0)
582 {
583 /**
584 * @tc.steps: step1. create db with valid SCHEMA_DEFINE_NON_ATTRI, strict mode and version 1.0.
585 * @tc.expected: step1. create successfully.
586 */
587 Option option = g_option;
588 option.isMemoryDb = false;
589 option.schema = SpliceToSchema(VALID_VERSION_1, VALID_MODE_1, SCHEMA_DEFINE_NON_ATTRI, VALID_INDEX_1);
590 g_nbSchemaUpgradeDelegate = DistributedDBNbTestTools::GetNbDelegateSuccess(g_manager, g_dbParameter1, option);
591 ASSERT_TRUE(g_manager != nullptr && g_nbSchemaUpgradeDelegate != nullptr);
592
593 CheckNullFieldSucceed(g_nbSchemaUpgradeDelegate);
594
595 EXPECT_TRUE(EndCaseDeleteDB(g_manager, g_nbSchemaUpgradeDelegate, STORE_ID_1, option.isMemoryDb));
596 }
597
598 /**
599 * @tc.name: SchemaNotNullDefault 012
600 * @tc.desc: Verify that schema db has the field that hasn't default value and not-null Attribute
601 * can insert the value field of which hasn't value
602 * @tc.type: FUNC
603 * @tc.require: SR000EUVPV
604 * @tc.author: fengxiaoyun
605 */
606 HWTEST_F(DistributeddbNbSchemaUpgradeTest, SchemaNotNullDefault012, TestSize.Level0)
607 {
608 /**
609 * @tc.steps: step1. create db with valid SCHEMA_DEFINE_NON_ATTRI, strict mode and version 1.0.
610 * @tc.expected: step1. create successfully.
611 */
612 Option option = g_option;
613 option.isMemoryDb = false;
614 option.schema = SpliceToSchema(VALID_VERSION_1, VALID_MODE_1, SCHEMA_DEFINE_NON_ATTRI, VALID_INDEX_1);
615 g_nbSchemaUpgradeDelegate = DistributedDBNbTestTools::GetNbDelegateSuccess(g_manager, g_dbParameter1, option);
616 ASSERT_TRUE(g_manager != nullptr && g_nbSchemaUpgradeDelegate != nullptr);
617
618 InsertVoidFieldSteps(g_nbSchemaUpgradeDelegate, OK);
619
620 /**
621 * @tc.steps: step9. check the data in db.
622 * @tc.expected: step9. can find all the Entries and all the value hasn't the field which is void when it inserted
623 */
624 vector<Entry> entriesGot;
625 EXPECT_EQ(g_nbSchemaUpgradeDelegate->GetEntries(KEY_EMPTY, entriesGot), OK);
626 sort(entriesGot.begin(), entriesGot.end(), DistributedTestTools::CompareKey);
627 string stringValue1v(entriesGot[INDEX_ZEROTH].value.begin(), entriesGot[INDEX_ZEROTH].value.end());
628 string stringValue2v(entriesGot[INDEX_FIRST].value.begin(), entriesGot[INDEX_FIRST].value.end());
629 string stringValue3v(entriesGot[INDEX_SECOND].value.begin(), entriesGot[INDEX_SECOND].value.end());
630 string stringValue4v(entriesGot[INDEX_THIRD].value.begin(), entriesGot[INDEX_THIRD].value.end());
631 string stringValue5v(entriesGot[INDEX_FORTH].value.begin(), entriesGot[INDEX_FORTH].value.end());
632 string stringValue6v(entriesGot[INDEX_FIFTH].value.begin(), entriesGot[INDEX_FIFTH].value.end());
633 string stringValue7v(entriesGot[INDEX_SIXTH].value.begin(), entriesGot[INDEX_SIXTH].value.end());
634 EXPECT_EQ(stringValue1v.find("\"field1\":\"json\""), std::string::npos);
635 EXPECT_EQ(stringValue2v.find("\"field3\":0"), std::string::npos);
636 EXPECT_EQ(stringValue3v.find("\"field4\":true"), std::string::npos);
637 EXPECT_EQ(stringValue4v.find("\"field5\":2021456"), std::string::npos);
638 EXPECT_EQ(stringValue5v.find("\"field6\":2021.2"), std::string::npos);
639 EXPECT_EQ(stringValue6v.find("\"field1\":\"json\""), std::string::npos);
640 EXPECT_EQ(stringValue6v.find("\"field4\":true"), std::string::npos);
641 EXPECT_EQ(stringValue6v.find("\"field6\":2021.2"), std::string::npos);
642 EXPECT_EQ(stringValue7v.find("\"field1\":\"json\""), std::string::npos);
643 EXPECT_EQ(stringValue7v.find("\"field3\":0"), std::string::npos);
644 EXPECT_EQ(stringValue7v.find("\"field4\":true"), std::string::npos);
645 EXPECT_EQ(stringValue7v.find("\"field5\":2021456"), std::string::npos);
646 EXPECT_EQ(stringValue7v.find("\"field6\":2021.2"), std::string::npos);
647
648 EXPECT_TRUE(EndCaseDeleteDB(g_manager, g_nbSchemaUpgradeDelegate, STORE_ID_1, option.isMemoryDb));
649 }
650
651 /**
652 * @tc.name: UpgradeKv 001
653 * @tc.desc: Verify that old version db that has the schema format record, and the db can be opened with the
654 * corresponding schema-define which has not-null attribute and default value, and at the same time upgrade the db.
655 * @tc.type: FUNC
656 * @tc.require: SR000EUVPV
657 * @tc.author: fengxiaoyun
658 */
659 HWTEST_F(DistributeddbNbSchemaUpgradeTest, UpgradeKv001, TestSize.Level0)
660 {
661 /**
662 * @tc.steps: step1. create old version db and insert two records one of which has all the
663 * SCHEMA_DEFINE_NNULL_DEFAULT format value the other one only has the SCHEMA_DEFINE_NNULL_DEFAULT
664 * and all the field are void.
665 * @tc.expected: step1. create and insert successfully.
666 */
667 Option option = g_option;
668 option.isMemoryDb = false;
669 g_nbSchemaUpgradeDelegate = DistributedDBNbTestTools::GetNbDelegateSuccess(g_manager, g_dbParameter1, option);
670 ASSERT_TRUE(g_manager != nullptr && g_nbSchemaUpgradeDelegate != nullptr);
671
672 string schemaString1 = "{\"field1\":\"schema\",\"field2\":{\"field3\":123,\"field4\":false,"
673 "\"field1\":{\"field5\":123567,\"field2\":{\"field6\":-123.456}}}}";
674 Value value1(schemaString1.begin(), schemaString1.end());
675 EXPECT_EQ(DistributedDBNbTestTools::Put(*g_nbSchemaUpgradeDelegate, KEY_1, value1), OK);
676 string schemaString2 = "{\"field2\":{\"field1\":{\"field2\":{}}}}";
677 Value value2(schemaString2.begin(), schemaString2.end());
678 EXPECT_EQ(DistributedDBNbTestTools::Put(*g_nbSchemaUpgradeDelegate, KEY_2, value2), OK);
679 /**
680 * @tc.steps: step2. close the old db.
681 * @tc.expected: step2. close successfully.
682 */
683 EXPECT_TRUE(DistributedDBNbTestTools::CloseNbAndRelease(g_manager, g_nbSchemaUpgradeDelegate));
684
685 /**
686 * @tc.steps: step3. reopen the db again using the schema define option.
687 * @tc.expected: step3. create successfully.
688 */
689 option.schema = SpliceToSchema(VALID_VERSION_1, VALID_MODE_1, SCHEMA_DEFINE_NNULL_DEFAULT);
690 g_nbSchemaUpgradeDelegate = DistributedDBNbTestTools::GetNbDelegateSuccess(g_manager, g_dbParameter1, option);
691 ASSERT_TRUE(g_manager != nullptr && g_nbSchemaUpgradeDelegate != nullptr);
692
693 /**
694 * @tc.steps: step4. check the data in db with the the query EqualTo("field1","schema").Or().EqualTo("field2.
695 * field4",false).
696 * @tc.expected: step4. can find (k1, value1)(k2, value2) and value2 is filt with default value.
697 */
698 Query query = Query::Select().EqualTo("$.field1", "schema").Or().EqualTo("field2.field4", true);
699 vector<Entry> entriesGot;
700 EXPECT_EQ(g_nbSchemaUpgradeDelegate->GetEntries(query, entriesGot), OK);
701 sort(entriesGot.begin(), entriesGot.end(), DistributedTestTools::CompareKey);
702 string stringValue2d(entriesGot[INDEX_FIRST].value.begin(), entriesGot[INDEX_FIRST].value.end());
703 EXPECT_EQ(entriesGot[INDEX_ZEROTH].value, value1);
704 EXPECT_NE(stringValue2d.find("\"field1\":\"json\""), std::string::npos);
705 EXPECT_NE(stringValue2d.find("\"field3\":0"), std::string::npos);
706 EXPECT_NE(stringValue2d.find("\"field4\":true"), std::string::npos);
707 EXPECT_NE(stringValue2d.find("\"field5\":2021456"), std::string::npos);
708 EXPECT_NE(stringValue2d.find("\"field6\":2021.2"), std::string::npos);
709
710 EXPECT_TRUE(EndCaseDeleteDB(g_manager, g_nbSchemaUpgradeDelegate, STORE_ID_1, option.isMemoryDb));
711 }
712
713 /**
714 * @tc.name: UpgradeKv 002
715 * @tc.desc: Verify that old version db that has the schema format record, and the db can be opened with the
716 * corresponding schema-define which has not-null attribute but no default value, and upgrade the db.
717 * @tc.type: FUNC
718 * @tc.require: SR000EUVPV
719 * @tc.author: fengxiaoyun
720 */
721 HWTEST_F(DistributeddbNbSchemaUpgradeTest, UpgradeKv002, TestSize.Level0)
722 {
723 /**
724 * @tc.steps: step1. create old version db and insert one record which has all the SCHEMA_DEFINE_NNULL format value.
725 * @tc.expected: step1. create and insert successfully.
726 */
727 Option option = g_option;
728 option.isMemoryDb = false;
729 g_nbSchemaUpgradeDelegate = DistributedDBNbTestTools::GetNbDelegateSuccess(g_manager, g_dbParameter1, option);
730 ASSERT_TRUE(g_manager != nullptr && g_nbSchemaUpgradeDelegate != nullptr);
731
732 string schemaString = "{\"field1\":\"schema\",\"field2\":{\"field3\":123,\"field4\":false,"
733 "\"field1\":{\"field5\":123567,\"field2\":{\"field6\":-123.456}}}}";
734 Value value(schemaString.begin(), schemaString.end());
735 EXPECT_EQ(DistributedDBNbTestTools::Put(*g_nbSchemaUpgradeDelegate, KEY_1, value), OK);
736 /**
737 * @tc.steps: step2. close the old db.
738 * @tc.expected: step2. close successfully.
739 */
740 EXPECT_TRUE(DistributedDBNbTestTools::CloseNbAndRelease(g_manager, g_nbSchemaUpgradeDelegate));
741
742 /**
743 * @tc.steps: step3. reopen the db again using the schema define option.
744 * @tc.expected: step3. create successfully.
745 */
746 option.schema = SpliceToSchema(VALID_VERSION_1, VALID_MODE_1, SCHEMA_DEFINE_NNULL);
747 g_nbSchemaUpgradeDelegate = DistributedDBNbTestTools::GetNbDelegateSuccess(g_manager, g_dbParameter1, option);
748 ASSERT_TRUE(g_manager != nullptr && g_nbSchemaUpgradeDelegate != nullptr);
749
750 /**
751 * @tc.steps: step4. check the data in db with the the query LessThan("field2.field1.field2.field6",0).
752 * @tc.expected: step4. can find (k1, value1)(k2, value2) and value2 is filt with default value.
753 */
754 Query query = Query::Select().LessThan("field2.field1.field2.field6", 0);
755 vector<Entry> entriesGot;
756 EXPECT_EQ(g_nbSchemaUpgradeDelegate->GetEntries(query, entriesGot), OK);
757 EXPECT_EQ(entriesGot[INDEX_ZEROTH].value, value);
758
759 EXPECT_TRUE(EndCaseDeleteDB(g_manager, g_nbSchemaUpgradeDelegate, STORE_ID_1, option.isMemoryDb));
760 }
761
762 /**
763 * @tc.name: UpgradeKv 003
764 * @tc.desc: Verify that old version db that has the schema format record, and the db can be opened with the
765 * corresponding schema-define without not-null attribute but has default value, and upgrade the db.
766 * @tc.type: FUNC
767 * @tc.require: SR000EUVPV
768 * @tc.author: fengxiaoyun
769 */
770 HWTEST_F(DistributeddbNbSchemaUpgradeTest, UpgradeKv003, TestSize.Level0)
771 {
772 /**
773 * @tc.steps: step1. create old version db and insert three records one of which has all the SCHEMA_DEFINE_DEFAULT
774 * format value the second one has the void field6, and the third one only has the SCHEMA_DEFINE_DEFAULT format
775 * and all the field are void.
776 * @tc.expected: step1. create and insert successfully.
777 */
778 Option option = g_option;
779 option.isMemoryDb = false;
780 g_nbSchemaUpgradeDelegate = DistributedDBNbTestTools::GetNbDelegateSuccess(g_manager, g_dbParameter1, option);
781 ASSERT_TRUE(g_manager != nullptr && g_nbSchemaUpgradeDelegate != nullptr);
782
783 string schemaString1 = "{\"field1\":\"schema\",\"field2\":{\"field3\":123,\"field4\":false,"
784 "\"field1\":{\"field5\":123567,\"field2\":{\"field6\":-123.456}}}}";
785 Value value1(schemaString1.begin(), schemaString1.end());
786 EXPECT_EQ(DistributedDBNbTestTools::Put(*g_nbSchemaUpgradeDelegate, KEY_1, value1), OK);
787 string schemaString2 = "{\"field1\":\"schema\",\"field2\":{\"field3\":123,\"field4\":false,"
788 "\"field1\":{\"field5\":123567,\"field2\":{\"field6\":null}}}}";
789 Value value2(schemaString2.begin(), schemaString2.end());
790 EXPECT_EQ(DistributedDBNbTestTools::Put(*g_nbSchemaUpgradeDelegate, KEY_2, value2), OK);
791 string schemaString3 = "{\"field2\":{\"field1\":{\"field2\":{}}}}";
792 Value value3(schemaString3.begin(), schemaString3.end());
793 EXPECT_EQ(DistributedDBNbTestTools::Put(*g_nbSchemaUpgradeDelegate, KEY_3, value3), OK);
794 /**
795 * @tc.steps: step2. close the old db.
796 * @tc.expected: step2. close successfully.
797 */
798 EXPECT_TRUE(DistributedDBNbTestTools::CloseNbAndRelease(g_manager, g_nbSchemaUpgradeDelegate));
799
800 /**
801 * @tc.steps: step3. reopen the db again using the schema define option.
802 * @tc.expected: step3. create successfully.
803 */
804 option.schema = SpliceToSchema(VALID_VERSION_1, VALID_MODE_1, SCHEMA_DEFINE_DEFAULT);
805 g_nbSchemaUpgradeDelegate = DistributedDBNbTestTools::GetNbDelegateSuccess(g_manager, g_dbParameter1, option);
806 ASSERT_TRUE(g_manager != nullptr && g_nbSchemaUpgradeDelegate != nullptr);
807
808 /**
809 * @tc.steps: step4. check the data in db with the the query EqualTo("field2.field3", 123).Or().
810 * EqualTo("field2.field1.field2.field6", 2021.2).
811 * @tc.expected: step4. can find (k1, value1)(k2, value2)(k3, value3) and value2 and value3 are
812 * filt with default value.
813 */
814 Query query = Query::Select().EqualTo("field2.field3", 123).Or().EqualTo("field2.field1.field2.field6", 2021.2);
815 vector<Entry> entriesGot;
816 EXPECT_EQ(g_nbSchemaUpgradeDelegate->GetEntries(query, entriesGot), OK);
817 EXPECT_EQ(entriesGot[INDEX_ZEROTH].value, value1);
818 EXPECT_EQ(entriesGot[INDEX_FIRST].value, value2);
819 string stringValue3d(entriesGot[INDEX_SECOND].value.begin(), entriesGot[INDEX_SECOND].value.end());
820 EXPECT_NE(stringValue3d.find("\"field5\":2021456"), std::string::npos);
821
822 /**
823 * @tc.steps: step5. delete (k2, value2), update (k3, value3) to (k3, value2) and use
824 * GetResultSet(query=IsNotNull("field1")) interface to check the data in db.
825 * @tc.expected: step5. delete and update succeed and can only find (k1, value1) (k3, value2) in db.
826 */
827 EXPECT_EQ(DistributedDBNbTestTools::Delete(*g_nbSchemaUpgradeDelegate, KEY_2), OK);
828 EXPECT_EQ(DistributedDBNbTestTools::Put(*g_nbSchemaUpgradeDelegate, KEY_3, value2), OK);
829 KvStoreResultSet *resultSet = nullptr;
830 Query query2 = Query::Select().IsNotNull("field1");
831 EXPECT_EQ(g_nbSchemaUpgradeDelegate->GetEntries(query2, resultSet), OK);
832 EXPECT_EQ(resultSet->GetCount(), 2); // 2 records
833 Entry entry;
834 EXPECT_EQ(resultSet->MoveToNext(), true);
835 EXPECT_EQ(resultSet->GetEntry(entry), OK);
836 EXPECT_EQ(entry.value, value1);
837 EXPECT_EQ(resultSet->MoveToNext(), true);
838 EXPECT_EQ(resultSet->GetEntry(entry), OK);
839 EXPECT_EQ(entry.value, value2);
840 EXPECT_EQ(g_nbSchemaUpgradeDelegate->CloseResultSet(resultSet), OK);
841 resultSet = nullptr;
842
843 EXPECT_TRUE(EndCaseDeleteDB(g_manager, g_nbSchemaUpgradeDelegate, STORE_ID_1, option.isMemoryDb));
844 }
845
846 /**
847 * @tc.name: UpgradeKv 004
848 * @tc.desc: Verify that old version db that has the schema format record, and the db can be opened with the
849 * corresponding schema-define without not-null attribute and default value, and upgrade the db.
850 * @tc.type: FUNC
851 * @tc.require: SR000EUVPV
852 * @tc.author: fengxiaoyun
853 */
854 HWTEST_F(DistributeddbNbSchemaUpgradeTest, UpgradeKv004, TestSize.Level0)
855 {
856 /**
857 * @tc.steps: step1. create old version db and insert three records one of which has all the SCHEMA_DEFINE_NON_ATTRI
858 * format value the second one has the void field6, and the third one only has the SCHEMA_DEFINE_DEFAULT format
859 * and all the field are void.
860 * @tc.expected: step1. create and insert successfully.
861 */
862 Option option = g_option;
863 option.isMemoryDb = false;
864 g_nbSchemaUpgradeDelegate = DistributedDBNbTestTools::GetNbDelegateSuccess(g_manager, g_dbParameter1, option);
865 ASSERT_TRUE(g_manager != nullptr && g_nbSchemaUpgradeDelegate != nullptr);
866
867 string schemaString1 = "{\"field1\":\"schema\",\"field2\":{\"field3\":123,\"field4\":false,"
868 "\"field1\":{\"field5\":123567,\"field2\":{\"field6\":-123.456}}}}";
869 Value value1(schemaString1.begin(), schemaString1.end());
870 EXPECT_EQ(DistributedDBNbTestTools::Put(*g_nbSchemaUpgradeDelegate, KEY_1, value1), OK);
871 string schemaString2 = "{\"field1\":null,\"field2\":{\"field3\":null,\"field4\":null,"
872 "\"field1\":{\"field5\":null,\"field2\":{\"field6\":null}}}}";
873 Value value2(schemaString2.begin(), schemaString2.end());
874 EXPECT_EQ(DistributedDBNbTestTools::Put(*g_nbSchemaUpgradeDelegate, KEY_2, value2), OK);
875 string schemaString3 = "{\"field2\":{\"field1\":{\"field2\":{}}}}";
876 Value value3(schemaString3.begin(), schemaString3.end());
877 EXPECT_EQ(DistributedDBNbTestTools::Put(*g_nbSchemaUpgradeDelegate, KEY_3, value3), OK);
878 /**
879 * @tc.steps: step2. close the old db.
880 * @tc.expected: step2. close successfully.
881 */
882 EXPECT_TRUE(DistributedDBNbTestTools::CloseNbAndRelease(g_manager, g_nbSchemaUpgradeDelegate));
883
884 /**
885 * @tc.steps: step3. reopen the db again using the schema define option.
886 * @tc.expected: step3. create successfully.
887 */
888 option.schema = SpliceToSchema(VALID_VERSION_1, VALID_MODE_1, SCHEMA_DEFINE_NON_ATTRI);
889 g_nbSchemaUpgradeDelegate = DistributedDBNbTestTools::GetNbDelegateSuccess(g_manager, g_dbParameter1, option);
890 ASSERT_TRUE(g_manager != nullptr && g_nbSchemaUpgradeDelegate != nullptr);
891
892 /**
893 * @tc.steps: step4. check the data in db.
894 * @tc.expected: step4. can find (k1, value1)(k2, value2)(k3, value3).
895 */
896 vector<Entry> entriesGot;
897 EXPECT_EQ(g_nbSchemaUpgradeDelegate->GetEntries(KEY_EMPTY, entriesGot), OK);
898 EXPECT_EQ(entriesGot[INDEX_ZEROTH].value, value1);
899 EXPECT_EQ(entriesGot[INDEX_FIRST].value, value2);
900 EXPECT_EQ(entriesGot[INDEX_SECOND].value, value3);
901
902 /**
903 * @tc.steps: step5. delete (k3, value3), and insert (k3, value1) again and then use
904 * GetResultSet(query=IsNotNull("field1")) interface to check the data in db.
905 * @tc.expected: step5. delete and insert succeed and can find (k1, value1) (k2, value2) (k3, value1) in db.
906 */
907 EXPECT_EQ(DistributedDBNbTestTools::Delete(*g_nbSchemaUpgradeDelegate, KEY_3), OK);
908 EXPECT_EQ(DistributedDBNbTestTools::Put(*g_nbSchemaUpgradeDelegate, KEY_3, value1), OK);
909 KvStoreResultSet *resultSet = nullptr;
910 EXPECT_EQ(g_nbSchemaUpgradeDelegate->GetEntries(KEY_EMPTY, resultSet), OK);
911 Entry entry;
912 EXPECT_EQ(resultSet->MoveToNext(), true);
913 EXPECT_EQ(resultSet->GetEntry(entry), OK);
914 EXPECT_EQ(entry.value, value1);
915 EXPECT_EQ(resultSet->MoveToNext(), true);
916 EXPECT_EQ(resultSet->GetEntry(entry), OK);
917 EXPECT_EQ(entry.value, value2);
918 EXPECT_EQ(resultSet->MoveToNext(), true);
919 EXPECT_EQ(resultSet->GetEntry(entry), OK);
920 EXPECT_EQ(entry.value, value1);
921 EXPECT_EQ(g_nbSchemaUpgradeDelegate->CloseResultSet(resultSet), OK);
922
923 EXPECT_TRUE(EndCaseDeleteDB(g_manager, g_nbSchemaUpgradeDelegate, STORE_ID_1, option.isMemoryDb));
924 }
925
926 /**
927 * @tc.name: UpgradeKv 005
928 * @tc.desc: Verify that old version db that has the schema format record, and the db can't opened if the schema-define
929 * format is not the same as the value already exist.
930 * @tc.type: FUNC
931 * @tc.require: SR000EUVPV
932 * @tc.author: fengxiaoyun
933 */
934 HWTEST_F(DistributeddbNbSchemaUpgradeTest, UpgradeKv005, TestSize.Level0)
935 {
936 /**
937 * @tc.steps: step1. create old version db and insert one record which has all valid field value
938 * @tc.expected: step1. create and insert successfully.
939 */
940 KvStoreDelegateManager *manager = nullptr;
941 Option option1 = g_option;
942 option1.isMemoryDb = false;
943 KvStoreNbDelegate *delegate = DistributedDBNbTestTools::GetNbDelegateSuccess(manager, g_dbParameter1, option1);
944 ASSERT_TRUE(manager != nullptr && delegate != nullptr);
945
946 string schemaString1 = "{\"field1\":null,\"field2\":{\"field3\":null,\"field4\":null,"
947 "\"field1\":{\"field5\":null,\"field2\":{\"field6\":null}}}}";
948 Value value1(schemaString1.begin(), schemaString1.end());
949 EXPECT_EQ(DistributedDBNbTestTools::Put(*delegate, KEY_1, value1), OK);
950 /**
951 * @tc.steps: step2. close the old db.
952 * @tc.expected: step2. close successfully.
953 */
954 EXPECT_TRUE(DistributedDBNbTestTools::CloseNbAndRelease(manager, delegate));
955 /**
956 * @tc.steps: step3. reopen the db again using the SCHEMA_DEFINE_NNULL_DEFAULT as option.schema.
957 * @tc.expected: step3. reopen failed.
958 */
959 Option option2 = g_option;
960 option2.isMemoryDb = false;
961 option2.createIfNecessary = false;
962 option2.schema = SpliceToSchema(VALID_VERSION_1, VALID_MODE_1, SCHEMA_DEFINE_NNULL_DEFAULT);
963 DBStatus status;
964 g_nbSchemaUpgradeDelegate = DistributedDBNbTestTools::GetNbDelegateStatus(g_manager, status, g_dbParameter1,
965 option2);
966 ASSERT_TRUE(g_manager == nullptr && g_nbSchemaUpgradeDelegate == nullptr);
967 EXPECT_EQ(status, SCHEMA_VIOLATE_VALUE);
968
969 /**
970 * @tc.steps: step4. reopen db using old version and delete (k1, value1), and insert (k2, value2) field1 of
971 * which is null
972 * @tc.expected: step4. operate successfully.
973 */
974 option1.createIfNecessary = false;
975 delegate = DistributedDBNbTestTools::GetNbDelegateSuccess(manager, g_dbParameter1, option1);
976 ASSERT_TRUE(manager != nullptr && delegate != nullptr);
977
978 EXPECT_EQ(DistributedDBNbTestTools::Delete(*delegate, KEY_1), OK);
979 string schemaString2 = "{\"field1\":null,\"field2\":{\"field3\":123,\"field4\":false,"
980 "\"field1\":{\"field5\":123567,\"field2\":{\"field6\":-123.456}}}}";
981 Value value2(schemaString2.begin(), schemaString2.end());
982 EXPECT_EQ(DistributedDBNbTestTools::Put(*delegate, KEY_2, value2), OK);
983
984 /**
985 * @tc.steps: step5. close the old db.
986 * @tc.expected: step5. close successfully.
987 */
988 EXPECT_TRUE(DistributedDBNbTestTools::CloseNbAndRelease(manager, delegate));
989 /**
990 * @tc.steps: step6. reopen the db again using the SCHEMA_DEFINE_NNULL as option.schema.
991 * @tc.expected: step6. reopen failed.
992 */
993 option2.schema = SpliceToSchema(VALID_VERSION_1, VALID_MODE_2, SCHEMA_DEFINE_NNULL);
994 g_nbSchemaUpgradeDelegate = DistributedDBNbTestTools::GetNbDelegateStatus(g_manager, status, g_dbParameter1,
995 option2);
996 ASSERT_TRUE(g_manager == nullptr && g_nbSchemaUpgradeDelegate == nullptr);
997 EXPECT_EQ(status, SCHEMA_VIOLATE_VALUE);
998
999 /**
1000 * @tc.steps: step7. reopen db using old version and delete (k2, value2), and insert (k3, value3) all field of
1001 * which is null
1002 * @tc.expected: step7. operate successfully.
1003 */
1004 delegate = DistributedDBNbTestTools::GetNbDelegateSuccess(manager, g_dbParameter1, option1);
1005 ASSERT_TRUE(manager != nullptr && delegate != nullptr);
1006
1007 EXPECT_EQ(DistributedDBNbTestTools::Delete(*delegate, KEY_2), OK);
1008 string schemaString3 = "{\"field2\":{\"field1\":{\"field2\":{}}}}";
1009 Value value3(schemaString3.begin(), schemaString3.end());
1010 EXPECT_EQ(DistributedDBNbTestTools::Put(*delegate, KEY_3, value3), OK);
1011
1012 /**
1013 * @tc.steps: step5. close the old db.
1014 * @tc.expected: step5. close successfully.
1015 */
1016 EXPECT_TRUE(manager->CloseKvStore(delegate) == OK);
1017
1018 /**
1019 * @tc.steps: step6. reopen the db again using the SCHEMA_DEFINE_NNULL as option.schema.
1020 * @tc.expected: step6. reopen failed.
1021 */
1022 g_nbSchemaUpgradeDelegate = DistributedDBNbTestTools::GetNbDelegateStatus(g_manager, status, g_dbParameter1,
1023 option2);
1024 ASSERT_TRUE(g_manager == nullptr && g_nbSchemaUpgradeDelegate == nullptr);
1025 EXPECT_EQ(status, SCHEMA_VIOLATE_VALUE);
1026
1027 EXPECT_TRUE(manager->DeleteKvStore(STORE_ID_1) == OK);
1028 delete manager;
1029 manager = nullptr;
1030 }
1031
CheckAddNewFieldSucceed(KvStoreNbDelegate * & delegate)1032 void CheckAddNewFieldSucceed(KvStoreNbDelegate *&delegate)
1033 {
1034 /**
1035 * @tc.steps: step8. check the data in the new version db again.
1036 * @tc.expected: step8. can find value1, value2 and value3 in db also.
1037 */
1038 KvStoreResultSet *resultSet = nullptr;
1039 Query query = Query::Select().GreaterThanOrEqualTo("field2.field3", 0).OrderBy("$.field1", true);
1040 EXPECT_EQ(delegate->GetEntries(query, resultSet), OK);
1041 EXPECT_EQ(resultSet->GetCount(), 3); // 3 records
1042 vector<Entry> entriesGot;
1043 Entry entry;
1044 EXPECT_EQ(resultSet->MoveToNext(), true);
1045 EXPECT_EQ(resultSet->GetEntry(entry), OK);
1046 entriesGot.push_back(entry);
1047 EXPECT_EQ(resultSet->MoveToNext(), true);
1048 EXPECT_EQ(resultSet->GetEntry(entry), OK);
1049 entriesGot.push_back(entry);
1050 EXPECT_EQ(resultSet->MoveToNext(), true);
1051 EXPECT_EQ(resultSet->GetEntry(entry), OK);
1052 entriesGot.push_back(entry);
1053 sort(entriesGot.begin(), entriesGot.end(), DistributedTestTools::CompareKey);
1054
1055 string stringValue1u(entriesGot[INDEX_ZEROTH].value.begin(), entriesGot[INDEX_ZEROTH].value.end());
1056 EXPECT_NE(stringValue1u.find("\"field1\":\"schema\""), std::string::npos);
1057 EXPECT_NE(stringValue1u.find("\"field_add2\":100"), std::string::npos);
1058 EXPECT_NE(stringValue1u.find("\"field_add3\":false"), std::string::npos);
1059
1060 string stringValue2u(entriesGot[INDEX_FIRST].value.begin(), entriesGot[INDEX_FIRST].value.end());
1061 EXPECT_NE(stringValue2u.find("\"field5\":2021456"), std::string::npos);
1062 EXPECT_NE(stringValue2u.find("\"field_add2\":100"), std::string::npos);
1063 EXPECT_NE(stringValue2u.find("\"field_add3\":false"), std::string::npos);
1064
1065 string stringValue3u(entriesGot[INDEX_SECOND].value.begin(), entriesGot[INDEX_SECOND].value.end());
1066 EXPECT_NE(stringValue3u.find("\"field1\":\"json\""), std::string::npos);
1067 EXPECT_NE(stringValue3u.find("\"field_add1\":\"new field1\""), std::string::npos);
1068 EXPECT_NE(stringValue3u.find("\"field_add4\":[\"field1\",\"field2.field3\"]"), std::string::npos);
1069
1070 EXPECT_EQ(g_nbSchemaUpgradeDelegate->CloseResultSet(resultSet), OK);
1071 resultSet = nullptr;
1072 }
1073
1074 /**
1075 * @tc.name: UpgradeField 001
1076 * @tc.desc: Verify that the compatible mode schema db support to add field and change schema-index, and the new field
1077 * can be null or must has default value if can't be null, and can be in any nesting level.
1078 * @tc.type: FUNC
1079 * @tc.require: SR000EUVPV
1080 * @tc.author: fengxiaoyun
1081 */
1082 HWTEST_F(DistributeddbNbSchemaUpgradeTest, UpgradeField001, TestSize.Level0)
1083 {
1084 /**
1085 * @tc.steps: step1. create db with valid SCHEMA_DEFINE_NNULL_DEFAULT, compatible mode, version 1.0, valid
1086 * schema_index and schema_skipsize 1.
1087 * @tc.expected: step1. create successfully.
1088 */
1089 Option option = g_option;
1090 option.isMemoryDb = false;
1091 option.schema = SpliceToSchema(VALID_VERSION_1, VALID_MODE_2, SCHEMA_DEFINE_NNULL_DEFAULT,
1092 SCHMEA_INDEX_WITH_ONE_JOIN_INDEX, "1");
1093 g_nbSchemaUpgradeDelegate = DistributedDBNbTestTools::GetNbDelegateSuccess(g_manager, g_dbParameter1, option);
1094 ASSERT_TRUE(g_manager != nullptr && g_nbSchemaUpgradeDelegate != nullptr);
1095
1096 /**
1097 * @tc.steps: step2. insert valid value1 to DB all field of which has valid value.
1098 * @tc.expected: step2. insert succeed.
1099 */
1100 string stringValue1 = "a{\"field1\":\"schema\",\"field2\":{\"field3\":123,\"field4\":false,"
1101 "\"field1\":{\"field5\":123567,\"field2\":{\"field6\":-123.456}}}}";
1102 Value value1(stringValue1.begin(), stringValue1.end());
1103 EXPECT_EQ(DistributedDBNbTestTools::Put(*g_nbSchemaUpgradeDelegate, KEY_1, value1), OK);
1104
1105 /**
1106 * @tc.steps: step3. insert valid value2 to DB all field has no value.
1107 * @tc.expected: step3. insert succeed.
1108 */
1109 string stringValue2 = "x{\"field2\":{\"field1\":{\"field2\":{}}}}";
1110 Value value2(stringValue2.begin(), stringValue2.end());
1111 EXPECT_EQ(DistributedDBNbTestTools::Put(*g_nbSchemaUpgradeDelegate, KEY_2, value2), OK);
1112
1113 /**
1114 * @tc.steps: step4. check the data in db.
1115 * @tc.expected: step4. can find value1 and value2 in db.
1116 */
1117 vector<Entry> entriesGot;
1118 EXPECT_EQ(g_nbSchemaUpgradeDelegate->GetEntries(KEY_EMPTY, entriesGot), OK);
1119 ASSERT_EQ(static_cast<int>(entriesGot.size()), 2); // 2 records
1120 EXPECT_EQ(entriesGot[INDEX_ZEROTH].value, value1);
1121 string stringValue2n(entriesGot[INDEX_FIRST].value.begin(), entriesGot[INDEX_FIRST].value.end());
1122 EXPECT_NE(stringValue2n.find("\"field6\":2021.2"), std::string::npos);
1123
1124 /**
1125 * @tc.steps: step5. close the db but not delete it.
1126 * @tc.expected: step5. close succeed.
1127 */
1128 EXPECT_TRUE(DistributedDBNbTestTools::CloseNbAndRelease(g_manager, g_nbSchemaUpgradeDelegate));
1129
1130 /**
1131 * @tc.steps: step6. reopen the db with a new schema-define that include new field one of which hasn't not-null
1132 * attribute and default value, the other one has default field value but hasn't not-null attribute, the next
1133 * one has also not-null attribute and default field value, the last one has void field array,
1134 * and the upgrade schema_index
1135 * @tc.expected: step6. reopen succeed.
1136 */
1137 option.schema = SpliceToSchema(VALID_VERSION_1, VALID_MODE_2, COMPATIBLE_SCHEMA_DEFINE,
1138 SCHEMA_INDEX_WITH_MULTI_JOIN_INDEXS, "1");
1139 g_nbSchemaUpgradeDelegate = DistributedDBNbTestTools::GetNbDelegateSuccess(g_manager, g_dbParameter1, option);
1140 ASSERT_TRUE(g_manager != nullptr && g_nbSchemaUpgradeDelegate != nullptr);
1141
1142 /**
1143 * @tc.steps: step7. insert valid value3 to DB that include all the new field added.
1144 * @tc.expected: step7. insert succeed.
1145 */
1146 string stringValue3 = "c{\"field2\":{\"field3\":123,\"field4\":false,\"field1\":{\"field5\":123567,"
1147 "\"field2\":{\"field_add1\":\"new field1\"}}},\"field_add4\":[\"field1\",\"field2.field3\"]}";
1148 Value value3(stringValue3.begin(), stringValue3.end());
1149 EXPECT_EQ(DistributedDBNbTestTools::Put(*g_nbSchemaUpgradeDelegate, KEY_3, value3), OK);
1150
1151 CheckAddNewFieldSucceed(g_nbSchemaUpgradeDelegate);
1152
1153 EXPECT_TRUE(EndCaseDeleteDB(g_manager, g_nbSchemaUpgradeDelegate, STORE_ID_1, option.isMemoryDb));
1154 }
1155
1156 /**
1157 * @tc.name: UpgradeField 002
1158 * @tc.desc: Verify that the strict mode schema db don't support to add field.
1159 * @tc.type: FUNC
1160 * @tc.require: SR000EUVPV
1161 * @tc.author: fengxiaoyun
1162 */
1163 HWTEST_F(DistributeddbNbSchemaUpgradeTest, UpgradeField002, TestSize.Level0)
1164 {
1165 /**
1166 * @tc.steps: step1. create db with valid SCHEMA_DEFINE_NON_ATTRI, strict mode, version 1.0, valid
1167 * schema_index and schema_skipsize 1.
1168 * @tc.expected: step1. create successfully.
1169 */
1170 KvStoreDelegateManager *manager = nullptr;
1171 Option option = g_option;
1172 option.isMemoryDb = false;
1173 option.schema = SpliceToSchema(VALID_VERSION_1, VALID_MODE_1, SCHEMA_DEFINE_NON_ATTRI,
1174 SCHMEA_INDEX_WITH_ONE_JOIN_INDEX, "1");
1175 KvStoreNbDelegate *delegate = DistributedDBNbTestTools::GetNbDelegateSuccess(manager, g_dbParameter1, option);
1176 ASSERT_TRUE(manager != nullptr && delegate != nullptr);
1177
1178 /**
1179 * @tc.steps: step2. insert valid value1 to DB all field of which has valid value.
1180 * @tc.expected: step2. insert succeed.
1181 */
1182 string stringValue1 = "a{\"field1\":\"schema\",\"field2\":{\"field3\":123,\"field4\":false,"
1183 "\"field1\":{\"field5\":123567,\"field2\":{\"field6\":-123.456}}}}";
1184 Value value1(stringValue1.begin(), stringValue1.end());
1185 EXPECT_EQ(DistributedDBNbTestTools::Put(*delegate, KEY_1, value1), OK);
1186
1187 /**
1188 * @tc.steps: step3. insert valid value2 to DB all field has no value.
1189 * @tc.expected: step3. insert succeed.
1190 */
1191 string stringValue2 = "b{\"field2\":{\"field1\":{\"field2\":{}}}}";
1192 Value value2(stringValue2.begin(), stringValue2.end());
1193 EXPECT_EQ(DistributedDBNbTestTools::Put(*delegate, KEY_2, value2), OK);
1194
1195 /**
1196 * @tc.steps: step4. insert valid value3 to DB all field is null.
1197 * @tc.expected: step4. insert succeed.
1198 */
1199 string stringValue3 = "c{\"field1\":null,\"field2\":{\"field3\":null,\"field4\":null,"
1200 "\"field1\":{\"field5\":null,\"field2\":{\"field6\":null}}}}";
1201 Value value3(stringValue3.begin(), stringValue3.end());
1202 EXPECT_EQ(DistributedDBNbTestTools::Put(*delegate, KEY_3, value3), OK);
1203
1204 /**
1205 * @tc.steps: step4. check the data in db.
1206 * @tc.expected: step4. can find value1, value2 and value3 in db.
1207 */
1208 vector<Entry> entriesGot;
1209 EXPECT_EQ(delegate->GetEntries(KEY_EMPTY, entriesGot), OK);
1210 ASSERT_EQ(static_cast<int>(entriesGot.size()), 3); // 3 records
1211 string stringValue1n(entriesGot[INDEX_ZEROTH].value.begin(), entriesGot[INDEX_ZEROTH].value.end());
1212 string stringValue2n(entriesGot[INDEX_FIRST].value.begin(), entriesGot[INDEX_FIRST].value.end());
1213 string stringValue3n(entriesGot[INDEX_SECOND].value.begin(), entriesGot[INDEX_SECOND].value.end());
1214 EXPECT_NE(stringValue1n.find("\"field1\":\"schema\""), std::string::npos);
1215 EXPECT_EQ(stringValue2n, stringValue2);
1216 EXPECT_NE(stringValue3n.find("\"field1\":null"), std::string::npos);
1217 EXPECT_NE(stringValue3n.find("\"field4\":null"), std::string::npos);
1218
1219 /**
1220 * @tc.steps: step5. close the db but not delete it.
1221 * @tc.expected: step5. close succeed.
1222 */
1223 EXPECT_TRUE(manager->CloseKvStore(delegate) == OK);
1224 delegate = nullptr;
1225 /**
1226 * @tc.steps: step6. reopen the db with a new schema-define that include new field field_add1.
1227 * @tc.expected: step6. reopen failed.
1228 */
1229 std::string schemaDefineUpdate = "{\"field1\":\"STRING\",\"field2\":{\"field3\":\"INTEGER\",\"field4\":\"BOOL\","
1230 "\"field1\":{\"field5\":\"LONG\",\"field2\":{\"field6\":\"DOUBLE\"}}},\"field_add1\":\"STRING\"}";
1231 option.schema = SpliceToSchema(VALID_VERSION_1, VALID_MODE_1, schemaDefineUpdate,
1232 SCHMEA_INDEX_WITH_ONE_JOIN_INDEX, "1");
1233 DBStatus status;
1234 g_nbSchemaUpgradeDelegate = DistributedDBNbTestTools::GetNbDelegateStatus(g_manager, status, g_dbParameter1,
1235 option);
1236 ASSERT_TRUE(g_manager == nullptr && g_nbSchemaUpgradeDelegate == nullptr);
1237 EXPECT_EQ(status, SCHEMA_MISMATCH);
1238
1239 EXPECT_TRUE(manager->DeleteKvStore(STORE_ID_1) == OK);
1240 delete manager;
1241 manager = nullptr;
1242 }
1243
UpgradeDbWithInvalidSchemaDefine(Option & option)1244 void UpgradeDbWithInvalidSchemaDefine(Option &option)
1245 {
1246 /**
1247 * @tc.steps: step6. reopen the db with a new schema-define that will add field_add1, field_add2, field_add3,
1248 * field_add4 but will delete the original field field6.
1249 * @tc.expected: step6. reopen failed.
1250 */
1251 std::string schemaDefineUpdate1 = "{\"field1\":\"STRING,NOT NULL,DEFAULT \'json\'\",\"field2\":{\"field3\":"
1252 "\"INTEGER,NOT NULL,DEFAULT 0\",\"field4\":\"BOOL,NOT NULL,DEFAULT true\",\"field1\":{\"field5\":"
1253 "\"LONG,NOT NULL,DEFAULT 2021456\",\"field2\":{\"field_add1\":\"STRING\"},\"field_add2\":"
1254 "\"INTEGER,DEFAULT 100\"},\"field_add3\":\"BOOL,NOT NULL,DEFAULT false\"},\"field_add4\":[]}";
1255 option.schema = SpliceToSchema(VALID_VERSION_1, VALID_MODE_2, schemaDefineUpdate1,
1256 SCHEMA_INDEX_WITH_MULTI_JOIN_INDEXS, "1");
1257 DBStatus status;
1258 g_nbSchemaUpgradeDelegate = DistributedDBNbTestTools::GetNbDelegateStatus(g_manager, status, g_dbParameter1,
1259 option);
1260 EXPECT_TRUE(g_manager == nullptr && g_nbSchemaUpgradeDelegate == nullptr);
1261 EXPECT_EQ(status, SCHEMA_MISMATCH);
1262
1263 /**
1264 * @tc.steps: step7. reopen the db with a new schema-define that want to change default value of the original field,
1265 * and at the same time add field_add1, field_add2, field_add3, field_add4. And change the schema index.
1266 * @tc.expected: step7. reopen failed.
1267 */
1268 std::string schemaDefineUpdate2 = "{\"field1\":\"STRING,NOT NULL,DEFAULT \'json\'\",\"field2\":{\"field3\":"
1269 "\"INTEGER,NOT NULL,DEFAULT 100\",\"field4\":\"BOOL,NOT NULL,DEFAULT true\",\"field1\":{\"field5\":"
1270 "\"LONG,NOT NULL,DEFAULT 2021456\",\"field2\":{\"field6\":\"DOUBLE,NOT NULL,DEFAULT 2021.2\","
1271 "\"field_add1\":\"STRING\"},\"field_add2\":\"INTEGER,DEFAULT 100\"},\"field_add3\":"
1272 "\"BOOL,NOT NULL,DEFAULT false\"},\"field_add4\":[]}";
1273 option.schema = SpliceToSchema(VALID_VERSION_1, VALID_MODE_2, schemaDefineUpdate2,
1274 SCHEMA_INDEX_WITH_MULTI_JOIN_INDEXS, "1");
1275 g_nbSchemaUpgradeDelegate = DistributedDBNbTestTools::GetNbDelegateStatus(g_manager, status, g_dbParameter1,
1276 option);
1277 EXPECT_TRUE(g_manager == nullptr && g_nbSchemaUpgradeDelegate == nullptr);
1278 EXPECT_EQ(status, SCHEMA_MISMATCH);
1279
1280 /**
1281 * @tc.steps: step8. reopen the db with a new schema-define that want to change not-null attribute of the original
1282 * field, and at the same time add field_add1, field_add2, field_add3, field_add4 and change the schema index.
1283 * @tc.expected: step8. reopen failed.
1284 */
1285 std::string schemaDefineUpdate3 = "{\"field1\":\"STRING,NOT NULL,DEFAULT \'json\'\",\"field2\":{\"field3\":"
1286 "\"INTEGER,NOT NULL,DEFAULT 0\",\"field4\":\"BOOL,DEFAULT true\",\"field1\":{\"field5\":"
1287 "\"LONG,NOT NULL,DEFAULT 2021456\",\"field2\":{\"field6\":\"DOUBLE,NOT NULL,DEFAULT 2021.2\","
1288 "\"field_add1\":\"STRING\"},\"field_add2\":\"INTEGER,DEFAULT 100\"},\"field_add3\":"
1289 "\"BOOL,NOT NULL,DEFAULT false\"},\"field_add4\":[]}";
1290 option.schema = SpliceToSchema(VALID_VERSION_1, VALID_MODE_2, schemaDefineUpdate3,
1291 SCHEMA_INDEX_WITH_MULTI_JOIN_INDEXS, "1");
1292 g_nbSchemaUpgradeDelegate = DistributedDBNbTestTools::GetNbDelegateStatus(g_manager, status, g_dbParameter1,
1293 option);
1294 EXPECT_TRUE(g_manager == nullptr && g_nbSchemaUpgradeDelegate == nullptr);
1295 EXPECT_EQ(status, SCHEMA_MISMATCH);
1296
1297 /**
1298 * @tc.steps: step9. reopen the db with a new schema-define that add field_add1, field_add2, field_add3, field_add4,
1299 * field_add5 which has not-null attribute but hasn't default value, and change the schema index.
1300 * @tc.expected: step9. reopen failed.
1301 */
1302 std::string schemaDefineUpdate4 = "{\"field1\":\"STRING,NOT NULL,DEFAULT \'json\'\",\"field2\":{\"field3\":"
1303 "\"INTEGER,NOT NULL,DEFAULT 0\",\"field4\":\"BOOL,DEFAULT true\",\"field1\":{\"field5\":"
1304 "\"LONG,NOT NULL,DEFAULT 2021456\",\"field2\":{\"field6\":\"DOUBLE,NOT NULL,DEFAULT 2021.2\","
1305 "\"field_add1\":\"STRING\"},\"field_add2\":\"INTEGER,DEFAULT 100\"},\"field_add3\":"
1306 "\"BOOL,NOT NULL,DEFAULT false\"},\"field_add4\":[],\"field_add5\":\"STRING,NOT NULL\"}";
1307 option.schema = SpliceToSchema(VALID_VERSION_1, VALID_MODE_2, schemaDefineUpdate4,
1308 SCHEMA_INDEX_WITH_MULTI_JOIN_INDEXS, "1");
1309 g_nbSchemaUpgradeDelegate = DistributedDBNbTestTools::GetNbDelegateStatus(g_manager, status, g_dbParameter1,
1310 option);
1311 EXPECT_TRUE(g_manager == nullptr && g_nbSchemaUpgradeDelegate == nullptr);
1312 EXPECT_EQ(status, SCHEMA_MISMATCH);
1313 }
1314
1315 /**
1316 * @tc.name: UpgradeField 003
1317 * @tc.desc: Verify that when update the compatible mode schema db, it can't change the original field and its
1318 * attribute and the new added field mustn't has not-null attribute and no default value at the same time.
1319 * @tc.type: FUNC
1320 * @tc.require: SR000EUVPV
1321 * @tc.author: fengxiaoyun
1322 */
1323 HWTEST_F(DistributeddbNbSchemaUpgradeTest, UpgradeField003, TestSize.Level0)
1324 {
1325 /**
1326 * @tc.steps: step1. create db with valid SCHEMA_DEFINE_NNULL_DEFAULT, strict mode, version 1.0, valid
1327 * schema_index and schema_skipsize 1.
1328 * @tc.expected: step1. create successfully.
1329 */
1330 KvStoreDelegateManager *manager = nullptr;
1331 Option option = g_option;
1332 option.isMemoryDb = false;
1333 option.schema = SpliceToSchema(VALID_VERSION_1, VALID_MODE_2, SCHEMA_DEFINE_NNULL_DEFAULT,
1334 SCHMEA_INDEX_WITH_ONE_JOIN_INDEX, "1");
1335 KvStoreNbDelegate *delegate = DistributedDBNbTestTools::GetNbDelegateSuccess(manager, g_dbParameter1, option);
1336 ASSERT_TRUE(manager != nullptr && delegate != nullptr);
1337
1338 /**
1339 * @tc.steps: step2. insert valid value1 to DB all field of which has valid value.
1340 * @tc.expected: step2. insert succeed.
1341 */
1342 string stringValue1 = "a{\"field1\":\"schema\",\"field2\":{\"field3\":123,\"field4\":false,"
1343 "\"field1\":{\"field5\":123567,\"field2\":{\"field6\":-123.456}}}}";
1344 Value value1(stringValue1.begin(), stringValue1.end());
1345 EXPECT_EQ(DistributedDBNbTestTools::Put(*delegate, KEY_1, value1), OK);
1346
1347 /**
1348 * @tc.steps: step3. insert valid value2 to DB all field has no value.
1349 * @tc.expected: step3. insert succeed.
1350 */
1351 string stringValue2 = "b{\"field2\":{\"field1\":{\"field2\":{}}}}";
1352 Value value2(stringValue2.begin(), stringValue2.end());
1353 EXPECT_EQ(DistributedDBNbTestTools::Put(*delegate, KEY_2, value2), OK);
1354
1355 /**
1356 * @tc.steps: step4. check the data in db.
1357 * @tc.expected: step4. can find value1, value2 and value3 in db.
1358 */
1359 vector<Entry> entriesGot;
1360 EXPECT_EQ(delegate->GetEntries(KEY_EMPTY, entriesGot), OK);
1361 ASSERT_EQ(static_cast<int>(entriesGot.size()), 2); // 2 records
1362 EXPECT_EQ(entriesGot[INDEX_ZEROTH].value, value1);
1363 string stringValue2n(entriesGot[INDEX_FIRST].value.begin(), entriesGot[INDEX_FIRST].value.end());
1364 EXPECT_NE(stringValue2n.find("\"field1\":\"json\""), std::string::npos);
1365 EXPECT_NE(stringValue2n.find("\"field3\":0"), std::string::npos);
1366 EXPECT_NE(stringValue2n.find("\"field4\":true"), std::string::npos);
1367 EXPECT_NE(stringValue2n.find("\"field5\":2021456"), std::string::npos);
1368 EXPECT_NE(stringValue2n.find("\"field6\":2021.2"), std::string::npos);
1369
1370 /**
1371 * @tc.steps: step5. close the db but not delete it.
1372 * @tc.expected: step5. close succeed.
1373 */
1374 EXPECT_TRUE(manager->CloseKvStore(delegate) == OK);
1375 delegate = nullptr;
1376
1377 UpgradeDbWithInvalidSchemaDefine(option);
1378
1379 EXPECT_TRUE(manager->DeleteKvStore(STORE_ID_1) == OK);
1380 delete manager;
1381 manager = nullptr;
1382 }
1383 } // end of namespace DistributeddbNbSchemaUpgradeDb