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
16 #ifndef OMIT_JSON
17 #include <gtest/gtest.h>
18 #include <cmath>
19
20 #include "db_errno.h"
21 #include "distributeddb_tools_unit_test.h"
22 #include "log_print.h"
23 #include "schema_constant.h"
24 #include "schema_object.h"
25 #include "schema_utils.h"
26
27 using namespace std;
28 using namespace testing::ext;
29 using namespace DistributedDB;
30
31 namespace {
32 const std::string VALID_SCHEMA_FULL_DEFINE = "{\"SCHEMA_VERSION\":\"1.0\","
33 "\"SCHEMA_MODE\":\"STRICT\","
34 "\"SCHEMA_DEFINE\":{"
35 "\"field_name1\":\"BOOL\","
36 "\"field_name2\":{"
37 "\"field_name3\":\"INTEGER, NOT NULL\","
38 "\"field_name4\":\"LONG, DEFAULT 100\","
39 "\"field_name5\":\"DOUBLE, NOT NULL, DEFAULT 3.14\","
40 "\"field_name6\":\"STRING, NOT NULL, DEFAULT '3.1415'\","
41 "\"field_name7\":[],"
42 "\"field_name8\":{}"
43 "}"
44 "},"
45 "\"SCHEMA_INDEXES\":[\"$.field_name1\", \"$.field_name2.field_name6\"]}";
46 const std::string VALID_SCHEMA_INDEX_EMPTY = "{\"SCHEMA_VERSION\":\"1.0\","
47 "\"SCHEMA_MODE\":\"STRICT\","
48 "\"SCHEMA_DEFINE\":{"
49 "\"field_name1\":\"BOOL\""
50 "},"
51 "\"SCHEMA_INDEXES\":[]}";
52 const std::string VALID_SCHEMA_NO_INDEX = "{\"SCHEMA_VERSION\":\"1.0\","
53 "\"SCHEMA_MODE\":\"STRICT\","
54 "\"SCHEMA_DEFINE\":{"
55 "\"field_name1\":\"BOOL\""
56 "}}";
57 const std::string VALID_SCHEMA_PRE_SUF_BLANK = "{\"SCHEMA_VERSION\":\" 1.0\","
58 "\"SCHEMA_MODE\":\"STRICT \","
59 "\"SCHEMA_DEFINE\":{"
60 "\"field_name1\":\" BOOL \""
61 "}}";
62
63 const std::string INVALID_SCHEMA_INVALID_JSON = "[\"$.field_name1\", \"$.field_name2.field_name6\"]";
64 const std::string INVALID_SCHEMA_LESS_META_FIELD = "{\"SCHEMA_VERSION\":\" 1.0\","
65 "\"SCHEMA_MODE\":\"STRICT\"}";
66 const std::string INVALID_SCHEMA_MORE_META_FIELD = "{\"SCHEMA_VERSION\":\"1.0\","
67 "\"SCHEMA_MODE\":\"STRICT\","
68 "\"SCHEMA_DEFINE\":{"
69 "\"field_name1\":\"BOOL\""
70 "},"
71 "\"SCHEMA_UNDEFINE_META_FIELD\":[]}";
72 const std::string INVALID_SCHEMA_WRONG_VERSION = "{\"SCHEMA_VERSION\":\"1.1\","
73 "\"SCHEMA_MODE\":\"STRICT\","
74 "\"SCHEMA_DEFINE\":{"
75 "\"field_name1\":\"BOOL\""
76 "}}";
77 const std::string INVALID_SCHEMA_WRONG_MODE = "{\"SCHEMA_VERSION\":\"1.0\","
78 "\"SCHEMA_MODE\":\"WRONG_MODE\","
79 "\"SCHEMA_DEFINE\":{"
80 "\"field_name1\":\"BOOL\""
81 "}}";
82
83 const std::string INVALID_SCHEMA_DEFINE_EMPTY = "{\"SCHEMA_VERSION\":\"1.0\","
84 "\"SCHEMA_MODE\":\"STRICT\","
85 "\"SCHEMA_DEFINE\":{}}";
86 const std::string INVALID_SCHEMA_DEFINE_NEST_TOO_DEEP = "{\"SCHEMA_VERSION\":\"1.0\","
87 "\"SCHEMA_MODE\":\"STRICT\","
88 "\"SCHEMA_DEFINE\":{"
89 "\"field_name1\":{"
90 "\"field_name2\":{"
91 "\"field_name3\":{"
92 "\"field_name4\":{"
93 "\"field_name5\":{"
94 "}}}}}}}";
95 const std::string INVALID_SCHEMA_DEFINE_INVALID_FIELD_NAME = "{\"SCHEMA_VERSION\":\"1.0\","
96 "\"SCHEMA_MODE\":\"STRICT\","
97 "\"SCHEMA_DEFINE\":{"
98 "\"12345\":\"BOOL\""
99 "}}";
100 const std::string INVALID_SCHEMA_DEFINE_INVALID_FIELD_ATTR = "{\"SCHEMA_VERSION\":\"1.0\","
101 "\"SCHEMA_MODE\":\"STRICT\","
102 "\"SCHEMA_DEFINE\":{"
103 "\"field_name1\":\"BOOL, NOT NULL, DEFAULT null\""
104 "}}";
105 const std::string INVALID_SCHEMA_DEFINE_INVALID_ARRAY_TYPE = "{\"SCHEMA_VERSION\":\"1.0\","
106 "\"SCHEMA_MODE\":\"STRICT\","
107 "\"SCHEMA_DEFINE\":{"
108 "\"field_name1\":[3.14]"
109 "}}";
110
111 const std::string INVALID_SCHEMA_INDEX_INVALID = "{\"SCHEMA_VERSION\":\"1.0\","
112 "\"SCHEMA_MODE\":\"STRICT\","
113 "\"SCHEMA_DEFINE\":{"
114 "\"field_name1\":\"BOOL\""
115 "},"
116 "\"SCHEMA_INDEXES\":[true, false]}";
117 const std::string INVALID_SCHEMA_INDEX_PATH_INVALID = "{\"SCHEMA_VERSION\":\"1.0\","
118 "\"SCHEMA_MODE\":\"STRICT\","
119 "\"SCHEMA_DEFINE\":{"
120 "\"field_name1\":\"BOOL\""
121 "},"
122 "\"SCHEMA_INDEXES\":[\".field_name1\"]}";
123 const std::string INVALID_SCHEMA_INDEX_PATH_NOT_EXIST = "{\"SCHEMA_VERSION\":\"1.0\","
124 "\"SCHEMA_MODE\":\"STRICT\","
125 "\"SCHEMA_DEFINE\":{"
126 "\"field_name1\":\"BOOL\""
127 "},"
128 "\"SCHEMA_INDEXES\":[\"$.field_name2\"]}";
129 const std::string INVALID_SCHEMA_INDEX_PATH_NOT_INDEXABLE = "{\"SCHEMA_VERSION\":\"1.0\","
130 "\"SCHEMA_MODE\":\"STRICT\","
131 "\"SCHEMA_DEFINE\":{"
132 "\"field_name1\":[]"
133 "},"
134 "\"SCHEMA_INDEXES\":[\"$.field_name1\"]}";
135 const std::string INVALID_SCHEMA_INDEX_PATH_DUPLICATE = "{\"SCHEMA_VERSION\":\"1.0\","
136 "\"SCHEMA_MODE\":\"STRICT\","
137 "\"SCHEMA_DEFINE\":{"
138 "\"field_name1\":\"BOOL\""
139 "},"
140 "\"SCHEMA_INDEXES\":[\"$.field_name1\", \"$.field_name1\"]}";
141
142 const std::string SCHEMA_COMPARE_BASELINE = "{\"SCHEMA_VERSION\":\"1.0\","
143 "\"SCHEMA_MODE\":\"COMPATIBLE\","
144 "\"SCHEMA_DEFINE\":{"
145 "\"field_name1\":\"BOOL, NOT NULL\","
146 "\"field_name2\":\"INTEGER, DEFAULT 100\","
147 "\"field_name3\":{"
148 "\"field_name4\":\"STRING\","
149 "\"field_name5\":{}"
150 "}},"
151 "\"SCHEMA_INDEXES\":[\"field_name1\"]}";
152 const std::string SCHEMA_DEFINE_MORE_FIELD = "{\"SCHEMA_VERSION\":\"1.0\","
153 "\"SCHEMA_MODE\":\"COMPATIBLE\","
154 "\"SCHEMA_DEFINE\":{"
155 "\"field_name1\":\"BOOL, NOT NULL\","
156 "\"field_name2\":\"INTEGER, DEFAULT 100\","
157 "\"field_name3\":{"
158 "\"field_name4\":\"STRING\","
159 "\"field_more1\":\"LONG\","
160 "\"field_name5\":{"
161 "\"field_more2\":\"DOUBLE\""
162 "}}},"
163 "\"SCHEMA_INDEXES\":[\"field_name1\"]}";
164 const std::string SCHEMA_DEFINE_MORE_FIELD_NOTNULL_FORBID = "{\"SCHEMA_VERSION\":\"1.0\","
165 "\"SCHEMA_MODE\":\"COMPATIBLE\","
166 "\"SCHEMA_DEFINE\":{"
167 "\"field_name1\":\"BOOL, NOT NULL\","
168 "\"field_name2\":\"INTEGER, DEFAULT 100\","
169 "\"field_name3\":{"
170 "\"field_name4\":\"STRING\","
171 "\"field_more1\":\"LONG\","
172 "\"field_name5\":{"
173 "\"field_more2\":\"DOUBLE, NOT NULL\""
174 "}}},"
175 "\"SCHEMA_INDEXES\":[\"field_name1\"]}";
176 const std::string SCHEMA_DEFINE_MORE_FIELD_NOTNULL_PERMIT = "{\"SCHEMA_VERSION\":\"1.0\","
177 "\"SCHEMA_MODE\":\"COMPATIBLE\","
178 "\"SCHEMA_DEFINE\":{"
179 "\"field_name1\":\"BOOL, NOT NULL\","
180 "\"field_name2\":\"INTEGER, DEFAULT 100\","
181 "\"field_name3\":{"
182 "\"field_name4\":\"STRING\","
183 "\"field_more1\":\"LONG, NOT NULL, DEFAULT 88\","
184 "\"field_name5\":{"
185 "\"field_more2\":\"DOUBLE\""
186 "}}},"
187 "\"SCHEMA_INDEXES\":[\"field_name1\"]}";
188 const std::string SCHEMA_DEFINE_LESS_FIELD = "{\"SCHEMA_VERSION\":\"1.0\","
189 "\"SCHEMA_MODE\":\"COMPATIBLE\","
190 "\"SCHEMA_DEFINE\":{"
191 "\"field_name1\":\"BOOL, NOT NULL\","
192 "\"field_name2\":\"INTEGER, DEFAULT 100\","
193 "\"field_name3\":{"
194 "\"field_name5\":{}"
195 "}},"
196 "\"SCHEMA_INDEXES\":[\"field_name1\"]}";
197 const std::string SCHEMA_INDEX_MORE = "{\"SCHEMA_VERSION\":\"1.0\","
198 "\"SCHEMA_MODE\":\"COMPATIBLE\","
199 "\"SCHEMA_DEFINE\":{"
200 "\"field_name1\":\"BOOL, NOT NULL\","
201 "\"field_name2\":\"INTEGER, DEFAULT 100\","
202 "\"field_name3\":{"
203 "\"field_name4\":\"STRING\","
204 "\"field_name5\":{}"
205 "}},"
206 "\"SCHEMA_INDEXES\":[\"field_name1\", [\"field_name2\", \"field_name3.field_name4\"]]}";
207 const std::string SCHEMA_INDEX_LESS = "{\"SCHEMA_VERSION\":\"1.0\","
208 "\"SCHEMA_MODE\":\"COMPATIBLE\","
209 "\"SCHEMA_DEFINE\":{"
210 "\"field_name1\":\"BOOL, NOT NULL\","
211 "\"field_name2\":\"INTEGER, DEFAULT 100\","
212 "\"field_name3\":{"
213 "\"field_name4\":\"STRING\","
214 "\"field_name5\":{}"
215 "}},"
216 "\"SCHEMA_INDEXES\":[]}";
217 const std::string SCHEMA_INDEX_CHANGE = "{\"SCHEMA_VERSION\":\"1.0\","
218 "\"SCHEMA_MODE\":\"COMPATIBLE\","
219 "\"SCHEMA_DEFINE\":{"
220 "\"field_name1\":\"BOOL, NOT NULL\","
221 "\"field_name2\":\"INTEGER, DEFAULT 100\","
222 "\"field_name3\":{"
223 "\"field_name4\":\"STRING\","
224 "\"field_name5\":{}"
225 "}},"
226 "\"SCHEMA_INDEXES\":[\"field_name1\", [\"field_name2\", \"field_name1\", \"field_name3.field_name4\"]]}";
227 const std::string SCHEMA_DEFINE_MORE_FIELD_MORE_INDEX = "{\"SCHEMA_VERSION\":\"1.0\","
228 "\"SCHEMA_MODE\":\"COMPATIBLE\","
229 "\"SCHEMA_DEFINE\":{"
230 "\"field_name1\":\"BOOL, NOT NULL\","
231 "\"field_name2\":\"INTEGER, DEFAULT 100\","
232 "\"field_name3\":{"
233 "\"field_name4\":\"STRING\","
234 "\"field_name5\":{"
235 "\"field_more1\":\"DOUBLE\""
236 "}}},"
237 "\"SCHEMA_INDEXES\":[\"field_name1\", [\"field_name2\", \"field_name3.field_name4\"]]}";
238 const std::string SCHEMA_SKIPSIZE_DIFFER = "{\"SCHEMA_VERSION\":\"1.0\","
239 "\"SCHEMA_MODE\":\"COMPATIBLE\","
240 "\"SCHEMA_SKIPSIZE\":1,"
241 "\"SCHEMA_DEFINE\":{"
242 "\"field_name1\":\"BOOL, NOT NULL\","
243 "\"field_name2\":\"INTEGER, DEFAULT 100\","
244 "\"field_name3\":{"
245 "\"field_name4\":\"STRING\","
246 "\"field_name5\":{}"
247 "}},"
248 "\"SCHEMA_INDEXES\":[\"field_name1\"]}";
249 const std::string SCHEMA_DEFINE_TYPE_DIFFER = "{\"SCHEMA_VERSION\":\"1.0\","
250 "\"SCHEMA_MODE\":\"COMPATIBLE\","
251 "\"SCHEMA_DEFINE\":{"
252 "\"field_name1\":\"BOOL, NOT NULL\","
253 "\"field_name2\":\"INTEGER, DEFAULT 100\","
254 "\"field_name3\":{"
255 "\"field_name4\":\"DOUBLE\","
256 "\"field_name5\":{}"
257 "}},"
258 "\"SCHEMA_INDEXES\":[\"field_name1\"]}";
259 const std::string SCHEMA_DEFINE_NOTNULL_DIFFER = "{\"SCHEMA_VERSION\":\"1.0\","
260 "\"SCHEMA_MODE\":\"COMPATIBLE\","
261 "\"SCHEMA_DEFINE\":{"
262 "\"field_name1\":\"BOOL\","
263 "\"field_name2\":\"INTEGER, DEFAULT 100\","
264 "\"field_name3\":{"
265 "\"field_name4\":\"STRING\","
266 "\"field_name5\":{}"
267 "}},"
268 "\"SCHEMA_INDEXES\":[\"field_name1\"]}";
269 const std::string SCHEMA_DEFINE_DEFAULT_DIFFER = "{\"SCHEMA_VERSION\":\"1.0\","
270 "\"SCHEMA_MODE\":\"COMPATIBLE\","
271 "\"SCHEMA_DEFINE\":{"
272 "\"field_name1\":\"BOOL, NOT NULL\","
273 "\"field_name2\":\"INTEGER, DEFAULT 88\","
274 "\"field_name3\":{"
275 "\"field_name4\":\"STRING\","
276 "\"field_name5\":{}"
277 "}},"
278 "\"SCHEMA_INDEXES\":[\"field_name1\"]}";
279
280 // Compare with VALID_SCHEMA_FULL_DEFINE
281 const std::string VALUE_LESS_FIELD = "{\"field_name1\":true,"
282 "\"field_name2\":{"
283 "\"field_name3\":100,"
284 "\"field_name8\":{"
285 "\"field_name9\":200"
286 "}"
287 "}}";
288 const std::string VALUE_MORE_FIELD = "{\"field_name1\":true,"
289 "\"field_name2\":{"
290 "\"field_name3\":100,"
291 "\"field_name4\":8589934592,"
292 "\"field_name5\":3.14,"
293 "\"field_name6\":\"3.1415926\","
294 "\"field_name7\":[true,1,\"inArray\"],"
295 "\"field_name8\":{"
296 "\"field_name9\":200"
297 "},"
298 "\"field_name10\":300"
299 "}}";
300 const std::string VALUE_TYPE_MISMATCH = "{\"field_name1\":true,"
301 "\"field_name2\":{"
302 "\"field_name3\":8589934592,"
303 "\"field_name4\":100,"
304 "\"field_name5\":3.14,"
305 "\"field_name6\":\"3.1415926\","
306 "\"field_name7\":[true,1,\"inArray\"],"
307 "\"field_name8\":{"
308 "\"field_name9\":200"
309 "}"
310 "}}";
311 const std::string VALUE_NOT_NULL_VIOLATION = "{\"field_name1\":true,"
312 "\"field_name2\":{"
313 "\"field_name3\":null,"
314 "\"field_name4\":8589934592,"
315 "\"field_name5\":3.14,"
316 "\"field_name6\":\"3.1415926\","
317 "\"field_name7\":[true,1,\"inArray\"],"
318 "\"field_name8\":{"
319 "\"field_name9\":200"
320 "}"
321 "}}";
322 const std::string VALUE_MATCH_STRICT_SCHEMA = "{\"field_name1\":true,"
323 "\"field_name2\":{"
324 "\"field_name3\":100,"
325 "\"field_name4\":8589934592,"
326 "\"field_name5\":3.14,"
327 "\"field_name6\":\"3.1415926\","
328 "\"field_name7\":[true,1,\"inArray\"],"
329 "\"field_name8\":{"
330 "\"field_name9\":200"
331 "}"
332 "}}";
333
334 // For test lacking field.
335 const std::string SCHEMA_FOR_TEST_NOTNULL_AND_DEFAULT = "{\"SCHEMA_VERSION\":\"1.0\","
336 "\"SCHEMA_MODE\":\"COMPATIBLE\","
337 "\"SCHEMA_DEFINE\":{"
338 "\"no_notnull_no_default\":\"BOOL\","
339 "\"level_0_nest_0\":{"
340 "\"has_notnull_no_default\":\"INTEGER, NOT NULL\","
341 "\"level_1_nest_0\":{"
342 "\"no_notnull_has_default\":\"LONG, DEFAULT 100\","
343 "\"has_notnull_has_default\":\"DOUBLE, NOT NULL, DEFAULT 3.14\","
344 "\"level_2_nest_0\":{"
345 "\"extra_0\":\"STRING, NOT NULL, DEFAULT '3.1415'\","
346 "\"extra_1\":\"DOUBLE\","
347 "\"extra_2\":[]"
348 "},"
349 "\"level_2_nest_1\":{"
350 "\"extra_3\":\"STRING\","
351 "\"extra_4\":{}"
352 "}"
353 "}"
354 "}"
355 "}}";
356 const std::string VALUE_NO_LACK_FIELD = "{"
357 "\"no_notnull_no_default\":true,"
358 "\"level_0_nest_0\":{"
359 "\"has_notnull_no_default\":10010,"
360 "\"level_1_nest_0\":{"
361 "\"no_notnull_has_default\":10086,"
362 "\"has_notnull_has_default\":1.38064,"
363 "\"level_2_nest_0\":{"
364 "\"extra_0\":\"BLOOM\","
365 "\"extra_1\":2.71828,"
366 "\"extra_2\":[]"
367 "},"
368 "\"level_2_nest_1\":{"
369 "\"extra_3\":\"Prejudice\","
370 "\"extra_4\":{}"
371 "}"
372 "}"
373 "}}";
374 const std::string VALUE_LACK_LEVEL_0_NEST_0 = "{\"no_notnull_no_default\":true}";
375 const std::string VALUE_LEVEL_0_NEST_0_NOT_OBJECT = "{\"no_notnull_no_default\":true,\"level_0_nest_0\":1}";
376 const std::string VALUE_LACK_LEVEL_1_NEST_0 = "{"
377 "\"no_notnull_no_default\":true,"
378 "\"level_0_nest_0\":{"
379 "\"has_notnull_no_default\":10010"
380 "}}";
381
SchemaSwitchMode(const std::string & oriSchemaStr)382 std::string SchemaSwitchMode(const std::string &oriSchemaStr)
383 {
384 std::string resultSchemaStr = oriSchemaStr;
385 auto iterForStrict = std::search(resultSchemaStr.begin(), resultSchemaStr.end(),
386 SchemaConstant::KEYWORD_MODE_STRICT,
387 SchemaConstant::KEYWORD_MODE_STRICT + strlen(SchemaConstant::KEYWORD_MODE_STRICT));
388 auto iterForCompatible = std::search(resultSchemaStr.begin(), resultSchemaStr.end(),
389 SchemaConstant::KEYWORD_MODE_COMPATIBLE,
390 SchemaConstant::KEYWORD_MODE_COMPATIBLE + strlen(SchemaConstant::KEYWORD_MODE_COMPATIBLE));
391 if (iterForStrict != resultSchemaStr.end()) {
392 resultSchemaStr.replace(iterForStrict, iterForStrict + strlen(SchemaConstant::KEYWORD_MODE_STRICT),
393 SchemaConstant::KEYWORD_MODE_COMPATIBLE,
394 SchemaConstant::KEYWORD_MODE_COMPATIBLE + strlen(SchemaConstant::KEYWORD_MODE_COMPATIBLE));
395 return resultSchemaStr;
396 }
397 if (iterForCompatible != resultSchemaStr.end()) {
398 resultSchemaStr.replace(iterForCompatible, iterForCompatible + strlen(SchemaConstant::KEYWORD_MODE_COMPATIBLE),
399 SchemaConstant::KEYWORD_MODE_STRICT,
400 SchemaConstant::KEYWORD_MODE_STRICT + strlen(SchemaConstant::KEYWORD_MODE_STRICT));
401 return resultSchemaStr;
402 }
403 return oriSchemaStr;
404 }
405 }
406
407 class DistributedDBSchemaObjectTest : public testing::Test {
408 public:
SetUpTestCase(void)409 static void SetUpTestCase(void) {};
TearDownTestCase(void)410 static void TearDownTestCase(void) {};
411 void SetUp() override;
TearDown()412 void TearDown() override {};
413 };
414
SetUp()415 void DistributedDBSchemaObjectTest::SetUp()
416 {
417 DistributedDBUnitTest::DistributedDBToolsUnitTest::PrintTestCaseInfo();
418 }
419
420 /**
421 * @tc.name: Parse Valid Schema 001
422 * @tc.desc: Parse Valid Schema
423 * @tc.type: FUNC
424 * @tc.require:
425 * @tc.author: xiaozhenjian
426 */
427 HWTEST_F(DistributedDBSchemaObjectTest, ParseValidSchema001, TestSize.Level1)
428 {
429 /**
430 * @tc.steps: step1. Parse valid schema with full define
431 * @tc.expected: step1. Parse Success.
432 */
433 SchemaObject schema1;
434 int stepOne = schema1.ParseFromSchemaString(VALID_SCHEMA_FULL_DEFINE);
435 EXPECT_TRUE(stepOne == E_OK);
436
437 /**
438 * @tc.steps: step2. Parse valid schema with empty index
439 * @tc.expected: step2. Parse Success.
440 */
441 SchemaObject schema2;
442 int stepTwo = schema2.ParseFromSchemaString(VALID_SCHEMA_INDEX_EMPTY);
443 EXPECT_TRUE(stepTwo == E_OK);
444
445 /**
446 * @tc.steps: step3. Parse valid schema with no index field
447 * @tc.expected: step3. Parse Success.
448 */
449 SchemaObject schema3;
450 int stepThree = schema3.ParseFromSchemaString(VALID_SCHEMA_NO_INDEX);
451 EXPECT_TRUE(stepThree == E_OK);
452
453 /**
454 * @tc.steps: step4. Parse valid schema with prefix of suffix blank
455 * @tc.expected: step4. Parse Success.
456 */
457 SchemaObject schema4;
458 int stepFour = schema4.ParseFromSchemaString(VALID_SCHEMA_PRE_SUF_BLANK);
459 EXPECT_TRUE(stepFour == E_OK);
460 }
461
462 /**
463 * @tc.name: Parse Invalid Schema 001
464 * @tc.desc: Parse Invalid Schema
465 * @tc.type: FUNC
466 * @tc.require:
467 * @tc.author: xiaozhenjian
468 */
469 HWTEST_F(DistributedDBSchemaObjectTest, ParseInvalidSchema001, TestSize.Level1)
470 {
471 /**
472 * @tc.steps: step1. Parse invalid schema which is not valid json
473 * @tc.expected: step1. Parse Fail.
474 */
475 SchemaObject schema1;
476 int stepOne = schema1.ParseFromSchemaString(INVALID_SCHEMA_INVALID_JSON);
477 EXPECT_TRUE(stepOne != E_OK);
478
479 /**
480 * @tc.steps: step2. Parse invalid schema with less field in depth 0
481 * @tc.expected: step2. Parse Fail.
482 */
483 SchemaObject schema2;
484 int stepTwo = schema2.ParseFromSchemaString(INVALID_SCHEMA_LESS_META_FIELD);
485 EXPECT_TRUE(stepTwo != E_OK);
486
487 /**
488 * @tc.steps: step3. Parse invalid schema with more field in depth 0
489 * @tc.expected: step3. Parse Fail.
490 */
491 SchemaObject schema3;
492 int stepThree = schema3.ParseFromSchemaString(INVALID_SCHEMA_MORE_META_FIELD);
493 EXPECT_TRUE(stepThree != E_OK);
494
495 /**
496 * @tc.steps: step4. Parse invalid schema with wrong version
497 * @tc.expected: step4. Parse Fail.
498 */
499 SchemaObject schema4;
500 int stepFour = schema4.ParseFromSchemaString(INVALID_SCHEMA_WRONG_VERSION);
501 EXPECT_TRUE(stepFour != E_OK);
502
503 /**
504 * @tc.steps: step5. Parse invalid schema with wrong mode
505 * @tc.expected: step5. Parse Fail.
506 */
507 SchemaObject schema5;
508 int stepFive = schema5.ParseFromSchemaString(INVALID_SCHEMA_WRONG_MODE);
509 EXPECT_TRUE(stepFive != E_OK);
510 }
511
512 /**
513 * @tc.name: Parse Invalid Schema 002
514 * @tc.desc: Parse Invalid Schema
515 * @tc.type: FUNC
516 * @tc.require:
517 * @tc.author: xiaozhenjian
518 */
519 HWTEST_F(DistributedDBSchemaObjectTest, ParseInvalidSchema002, TestSize.Level1)
520 {
521 /**
522 * @tc.steps: step1. Parse invalid schema which is empty define
523 * @tc.expected: step1. Parse Fail.
524 */
525 SchemaObject schema1;
526 int stepOne = schema1.ParseFromSchemaString(INVALID_SCHEMA_DEFINE_EMPTY);
527 EXPECT_TRUE(stepOne != E_OK);
528
529 /**
530 * @tc.steps: step2. Parse invalid schema with define nest too deep
531 * @tc.expected: step2. Parse Fail.
532 */
533 SchemaObject schema2;
534 int stepTwo = schema2.ParseFromSchemaString(INVALID_SCHEMA_DEFINE_NEST_TOO_DEEP);
535 EXPECT_TRUE(stepTwo != E_OK);
536
537 /**
538 * @tc.steps: step3. Parse invalid schema with invalid fieldname in define
539 * @tc.expected: step3. Parse Fail.
540 */
541 SchemaObject schema3;
542 int stepThree = schema3.ParseFromSchemaString(INVALID_SCHEMA_DEFINE_INVALID_FIELD_NAME);
543 EXPECT_TRUE(stepThree != E_OK);
544
545 /**
546 * @tc.steps: step4. Parse invalid schema with invalid field attribute in define
547 * @tc.expected: step4. Parse Fail.
548 */
549 SchemaObject schema4;
550 int stepFour = schema4.ParseFromSchemaString(INVALID_SCHEMA_DEFINE_INVALID_FIELD_ATTR);
551 EXPECT_TRUE(stepFour != E_OK);
552
553 /**
554 * @tc.steps: step5. Parse invalid schema with not empty array in define
555 * @tc.expected: step5. Parse Fail.
556 */
557 SchemaObject schema5;
558 int stepFive = schema5.ParseFromSchemaString(INVALID_SCHEMA_DEFINE_INVALID_ARRAY_TYPE);
559 EXPECT_TRUE(stepFive != E_OK);
560 }
561
562 /**
563 * @tc.name: Parse Invalid Schema 003
564 * @tc.desc: Parse Invalid Schema
565 * @tc.type: FUNC
566 * @tc.require:
567 * @tc.author: xiaozhenjian
568 */
569 HWTEST_F(DistributedDBSchemaObjectTest, ParseInvalidSchema003, TestSize.Level1)
570 {
571 /**
572 * @tc.steps: step1. Parse invalid schema with invalid array content
573 * @tc.expected: step1. Parse Fail.
574 */
575 SchemaObject schema1;
576 int stepOne = schema1.ParseFromSchemaString(INVALID_SCHEMA_INDEX_INVALID);
577 EXPECT_TRUE(stepOne != E_OK);
578
579 /**
580 * @tc.steps: step2. Parse invalid schema with invalid path
581 * @tc.expected: step2. Parse Fail.
582 */
583 SchemaObject schema2;
584 int stepTwo = schema2.ParseFromSchemaString(INVALID_SCHEMA_INDEX_PATH_INVALID);
585 EXPECT_TRUE(stepTwo != E_OK);
586
587 /**
588 * @tc.steps: step3. Parse invalid schema with path not exist
589 * @tc.expected: step3. Parse Fail.
590 */
591 SchemaObject schema3;
592 int stepThree = schema3.ParseFromSchemaString(INVALID_SCHEMA_INDEX_PATH_NOT_EXIST);
593 EXPECT_TRUE(stepThree != E_OK);
594
595 /**
596 * @tc.steps: step4. Parse invalid schema with path not indexable
597 * @tc.expected: step4. Parse Fail.
598 */
599 SchemaObject schema4;
600 int stepFour = schema4.ParseFromSchemaString(INVALID_SCHEMA_INDEX_PATH_NOT_INDEXABLE);
601 EXPECT_TRUE(stepFour != E_OK);
602
603 /**
604 * @tc.steps: step5. Parse invalid schema with duplicate
605 * @tc.expected: step5. Parse Fail.
606 */
607 SchemaObject schema5;
608 int stepFive = schema5.ParseFromSchemaString(INVALID_SCHEMA_INDEX_PATH_DUPLICATE);
609 EXPECT_TRUE(stepFive != E_OK);
610 }
611
612 /**
613 * @tc.name: Compare Equal Exactly 001
614 * @tc.desc: Compare Equal Exactly
615 * @tc.type: FUNC
616 * @tc.require:
617 * @tc.author: xiaozhenjian
618 */
619 HWTEST_F(DistributedDBSchemaObjectTest, CompareEqualExactly001, TestSize.Level1)
620 {
621 SchemaObject schemaOri;
622 int errCode = schemaOri.ParseFromSchemaString(VALID_SCHEMA_FULL_DEFINE);
623 EXPECT_TRUE(errCode == E_OK);
624
625 /**
626 * @tc.steps: step1. Compare two same schema with full define
627 * @tc.expected: step1. Equal exactly.
628 */
629 int stepOne = schemaOri.CompareAgainstSchemaString(VALID_SCHEMA_FULL_DEFINE);
630 EXPECT_TRUE(stepOne == -E_SCHEMA_EQUAL_EXACTLY);
631 }
632
633 /**
634 * @tc.name: Compare Unequal Compatible 001
635 * @tc.desc: Compare Unequal Compatible
636 * @tc.type: FUNC
637 * @tc.require:
638 * @tc.author: xiaozhenjian
639 */
640 HWTEST_F(DistributedDBSchemaObjectTest, CompareUnequalCompatible001, TestSize.Level1)
641 {
642 SchemaObject compatibleSchema;
643 int errCode = compatibleSchema.ParseFromSchemaString(SCHEMA_COMPARE_BASELINE);
644 EXPECT_EQ(errCode, E_OK);
645
646 /**
647 * @tc.steps: step1. new schema index more
648 * @tc.expected: step1. E_SCHEMA_UNEQUAL_COMPATIBLE.
649 */
650 errCode = compatibleSchema.CompareAgainstSchemaString(SCHEMA_INDEX_MORE);
651 EXPECT_EQ(errCode, -E_SCHEMA_UNEQUAL_COMPATIBLE);
652
653 /**
654 * @tc.steps: step2. new schema index less
655 * @tc.expected: step2. E_SCHEMA_UNEQUAL_COMPATIBLE.
656 */
657 errCode = compatibleSchema.CompareAgainstSchemaString(SCHEMA_INDEX_LESS);
658 EXPECT_EQ(errCode, -E_SCHEMA_UNEQUAL_COMPATIBLE);
659
660 /**
661 * @tc.steps: step3. new schema index change
662 * @tc.expected: step3. E_SCHEMA_UNEQUAL_COMPATIBLE.
663 */
664 errCode = compatibleSchema.CompareAgainstSchemaString(SCHEMA_INDEX_CHANGE);
665 EXPECT_EQ(errCode, -E_SCHEMA_UNEQUAL_COMPATIBLE);
666 }
667
668 /**
669 * @tc.name: Compare Unequal Compatible Upgrade 001
670 * @tc.desc: Compare Unequal Compatible Upgrade
671 * @tc.type: FUNC
672 * @tc.require:
673 * @tc.author: xiaozhenjian
674 */
675 HWTEST_F(DistributedDBSchemaObjectTest, CompareUnequalCompatibleUpgrade001, TestSize.Level1)
676 {
677 SchemaObject compatibleSchema;
678 int errCode = compatibleSchema.ParseFromSchemaString(SCHEMA_COMPARE_BASELINE);
679 EXPECT_EQ(errCode, E_OK);
680
681 /**
682 * @tc.steps: step1. compatible new schema more field define
683 * @tc.expected: step1. E_SCHEMA_UNEQUAL_COMPATIBLE_UPGRADE.
684 */
685 errCode = compatibleSchema.CompareAgainstSchemaString(SCHEMA_DEFINE_MORE_FIELD);
686 EXPECT_EQ(errCode, -E_SCHEMA_UNEQUAL_COMPATIBLE_UPGRADE);
687
688 /**
689 * @tc.steps: step2. compatible new schema more field with not null and default
690 * @tc.expected: step2. E_SCHEMA_UNEQUAL_COMPATIBLE_UPGRADE.
691 */
692 errCode = compatibleSchema.CompareAgainstSchemaString(SCHEMA_DEFINE_MORE_FIELD_NOTNULL_PERMIT);
693 EXPECT_EQ(errCode, -E_SCHEMA_UNEQUAL_COMPATIBLE_UPGRADE);
694
695 /**
696 * @tc.steps: step3. compatible new schema more field and more index
697 * @tc.expected: step3. E_SCHEMA_UNEQUAL_COMPATIBLE_UPGRADE.
698 */
699 errCode = compatibleSchema.CompareAgainstSchemaString(SCHEMA_DEFINE_MORE_FIELD_MORE_INDEX);
700 EXPECT_EQ(errCode, -E_SCHEMA_UNEQUAL_COMPATIBLE_UPGRADE);
701 }
702
703 /**
704 * @tc.name: Compare Unequal Incompatible 001
705 * @tc.desc: Compare Unequal Incompatible
706 * @tc.type: FUNC
707 * @tc.require:
708 * @tc.author: xiaozhenjian
709 */
710 HWTEST_F(DistributedDBSchemaObjectTest, CompareUnequalIncompatible001, TestSize.Level1)
711 {
712 SchemaObject strictSchema;
713 int errCode = strictSchema.ParseFromSchemaString(SchemaSwitchMode(SCHEMA_COMPARE_BASELINE));
714 EXPECT_EQ(errCode, E_OK);
715 SchemaObject compatibleSchema;
716 errCode = compatibleSchema.ParseFromSchemaString(SCHEMA_COMPARE_BASELINE);
717 EXPECT_EQ(errCode, E_OK);
718
719 /**
720 * @tc.steps: step1. strict new schema more field define
721 * @tc.expected: step1. E_SCHEMA_UNEQUAL_INCOMPATIBLE.
722 */
723 errCode = strictSchema.CompareAgainstSchemaString(SchemaSwitchMode(SCHEMA_DEFINE_MORE_FIELD));
724 EXPECT_EQ(errCode, -E_SCHEMA_UNEQUAL_INCOMPATIBLE);
725
726 /**
727 * @tc.steps: step2. compatible new schema more field but not null
728 * @tc.expected: step2. E_SCHEMA_UNEQUAL_INCOMPATIBLE.
729 */
730 errCode = compatibleSchema.CompareAgainstSchemaString(SCHEMA_DEFINE_MORE_FIELD_NOTNULL_FORBID);
731 EXPECT_EQ(errCode, -E_SCHEMA_UNEQUAL_INCOMPATIBLE);
732
733 /**
734 * @tc.steps: step3. new schema less field
735 * @tc.expected: step3. E_SCHEMA_UNEQUAL_INCOMPATIBLE.
736 */
737 errCode = compatibleSchema.CompareAgainstSchemaString(SCHEMA_DEFINE_LESS_FIELD);
738 EXPECT_EQ(errCode, -E_SCHEMA_UNEQUAL_INCOMPATIBLE);
739 errCode = strictSchema.CompareAgainstSchemaString(SchemaSwitchMode(SCHEMA_DEFINE_LESS_FIELD));
740 EXPECT_EQ(errCode, -E_SCHEMA_UNEQUAL_INCOMPATIBLE);
741
742 /**
743 * @tc.steps: step4. new schema skipsize differ
744 * @tc.expected: step4. E_SCHEMA_UNEQUAL_INCOMPATIBLE.
745 */
746 errCode = compatibleSchema.CompareAgainstSchemaString(SCHEMA_SKIPSIZE_DIFFER);
747 EXPECT_EQ(errCode, -E_SCHEMA_UNEQUAL_INCOMPATIBLE);
748
749 /**
750 * @tc.steps: step5. new schema type differ
751 * @tc.expected: step5. E_SCHEMA_UNEQUAL_INCOMPATIBLE.
752 */
753 errCode = compatibleSchema.CompareAgainstSchemaString(SCHEMA_DEFINE_TYPE_DIFFER);
754 EXPECT_EQ(errCode, -E_SCHEMA_UNEQUAL_INCOMPATIBLE);
755
756 /**
757 * @tc.steps: step6. new schema notnull differ
758 * @tc.expected: step6. E_SCHEMA_UNEQUAL_INCOMPATIBLE.
759 */
760 errCode = compatibleSchema.CompareAgainstSchemaString(SCHEMA_DEFINE_NOTNULL_DIFFER);
761 EXPECT_EQ(errCode, -E_SCHEMA_UNEQUAL_INCOMPATIBLE);
762
763 /**
764 * @tc.steps: step7. new schema default differ
765 * @tc.expected: step7. E_SCHEMA_UNEQUAL_INCOMPATIBLE.
766 */
767 errCode = compatibleSchema.CompareAgainstSchemaString(SCHEMA_DEFINE_DEFAULT_DIFFER);
768 EXPECT_EQ(errCode, -E_SCHEMA_UNEQUAL_INCOMPATIBLE);
769
770 /**
771 * @tc.steps: step8. new schema mode differ
772 * @tc.expected: step8. E_SCHEMA_UNEQUAL_INCOMPATIBLE.
773 */
774 errCode = compatibleSchema.CompareAgainstSchemaString(SchemaSwitchMode(SCHEMA_COMPARE_BASELINE));
775 EXPECT_EQ(errCode, -E_SCHEMA_UNEQUAL_INCOMPATIBLE);
776 }
777
778 /**
779 * @tc.name: Check Value 001
780 * @tc.desc: Check value both in strict and compatible mode
781 * @tc.type: FUNC
782 * @tc.require:
783 * @tc.author: xiaozhenjian
784 */
785 HWTEST_F(DistributedDBSchemaObjectTest, CheckValue001, TestSize.Level1)
786 {
787 SchemaObject schemaStrict;
788 int errCode = schemaStrict.ParseFromSchemaString(VALID_SCHEMA_FULL_DEFINE);
789 EXPECT_TRUE(errCode == E_OK);
790
791 /**
792 * @tc.steps: step1. value has less field in strict mode
793 * @tc.expected: step1. E_VALUE_MATCH_AMENDED.
794 */
795 ValueObject value1;
796 errCode = value1.Parse(VALUE_LESS_FIELD);
797 EXPECT_TRUE(errCode == E_OK);
798 int stepOne = schemaStrict.CheckValueAndAmendIfNeed(ValueSource::FROM_LOCAL, value1);
799 EXPECT_TRUE(stepOne == -E_VALUE_MATCH_AMENDED);
800
801 /**
802 * @tc.steps: step2. value has more field in strict mode
803 * @tc.expected: step2. E_VALUE_MISMATCH_FEILD_COUNT.
804 */
805 ValueObject value2;
806 errCode = value2.Parse(VALUE_MORE_FIELD);
807 EXPECT_TRUE(errCode == E_OK);
808 int stepTwo = schemaStrict.CheckValueAndAmendIfNeed(ValueSource::FROM_LOCAL, value2);
809 EXPECT_TRUE(stepTwo == -E_VALUE_MISMATCH_FEILD_COUNT);
810
811 /**
812 * @tc.steps: step3. value type mismatch
813 * @tc.expected: step3. E_VALUE_MISMATCH_FEILD_TYPE.
814 */
815 ValueObject value3;
816 errCode = value3.Parse(VALUE_TYPE_MISMATCH);
817 EXPECT_TRUE(errCode == E_OK);
818 int stepThree = schemaStrict.CheckValueAndAmendIfNeed(ValueSource::FROM_LOCAL, value3);
819 EXPECT_TRUE(stepThree == -E_VALUE_MISMATCH_FEILD_TYPE);
820
821 /**
822 * @tc.steps: step4. value not null violation
823 * @tc.expected: step4. E_VALUE_MISMATCH_CONSTRAINT.
824 */
825 ValueObject value4;
826 errCode = value4.Parse(VALUE_NOT_NULL_VIOLATION);
827 EXPECT_TRUE(errCode == E_OK);
828 int stepFour = schemaStrict.CheckValueAndAmendIfNeed(ValueSource::FROM_LOCAL, value4);
829 EXPECT_TRUE(stepFour == -E_VALUE_MISMATCH_CONSTRAINT);
830
831 /**
832 * @tc.steps: step5. value exactly match strict mode
833 * @tc.expected: step5. E_VALUE_MATCH.
834 */
835 ValueObject value5;
836 errCode = value5.Parse(VALUE_MATCH_STRICT_SCHEMA);
837 EXPECT_TRUE(errCode == E_OK);
838 int stepFive = schemaStrict.CheckValueAndAmendIfNeed(ValueSource::FROM_LOCAL, value5);
839 EXPECT_TRUE(stepFive == -E_VALUE_MATCH);
840
841 /**
842 * @tc.steps: step6. value has more field in compatible mode
843 * @tc.expected: step6. E_VALUE_MATCH.
844 */
845 std::string compatibleSchemaString = SchemaSwitchMode(VALID_SCHEMA_FULL_DEFINE);
846 SchemaObject schemaCompatible;
847 errCode = schemaCompatible.ParseFromSchemaString(compatibleSchemaString);
848 EXPECT_TRUE(errCode == E_OK);
849
850 ValueObject value6;
851 std::vector<uint8_t> moreFieldValueVector(VALUE_MORE_FIELD.begin(), VALUE_MORE_FIELD.end());
852 errCode = value6.Parse(moreFieldValueVector);
853 EXPECT_TRUE(errCode == E_OK);
854 int stepSix = schemaCompatible.CheckValueAndAmendIfNeed(ValueSource::FROM_LOCAL, value6);
855 EXPECT_TRUE(stepSix == -E_VALUE_MATCH);
856 }
857
858 /**
859 * @tc.name: Check Value 002
860 * @tc.desc: Check value that has offset
861 * @tc.type: FUNC
862 * @tc.require:
863 * @tc.author: xiaozhenjian
864 */
865 HWTEST_F(DistributedDBSchemaObjectTest, CheckValue002, TestSize.Level1)
866 {
867 SchemaObject schemaStrict;
868 int errCode = schemaStrict.ParseFromSchemaString(VALID_SCHEMA_FULL_DEFINE);
869 EXPECT_TRUE(errCode == E_OK);
870
871 /**
872 * @tc.steps: step1. value has less field in strict mode
873 * @tc.expected: step1. E_VALUE_MATCH and data before offset not change.
874 */
875 std::string beforeOffset = "BOM_CONTENT:";
876 std::string strValue = beforeOffset + VALUE_MATCH_STRICT_SCHEMA;
877 vector<uint8_t> vecValue(strValue.begin(), strValue.end());
878
879 ValueObject value1;
880 errCode = value1.Parse(vecValue.data(), vecValue.data() + vecValue.size(), beforeOffset.size());
881 EXPECT_TRUE(errCode == E_OK);
882
883 int stepOne = schemaStrict.CheckValueAndAmendIfNeed(ValueSource::FROM_LOCAL, value1);
884 EXPECT_TRUE(stepOne == -E_VALUE_MATCH);
885
886 std::string valueToString = value1.ToString();
887 EXPECT_EQ(strValue.size(), valueToString.size());
888 std::string valueBeforeOffset = valueToString.substr(0, beforeOffset.size());
889 EXPECT_EQ(valueBeforeOffset, beforeOffset);
890 }
891
892 /**
893 * @tc.name: Value Edit 001
894 * @tc.desc: Edit the value in right way
895 * @tc.type: FUNC
896 * @tc.require:
897 * @tc.author: xiaozhenjian
898 */
899 HWTEST_F(DistributedDBSchemaObjectTest, ValueEdit001, TestSize.Level1)
900 {
901 /**
902 * @tc.steps: step1. Insert value to ValueObject in different depth
903 * @tc.expected: step1. Check insert successful
904 */
905 ValueObject testObject;
906 FieldValue val;
907
908 val.stringValue = "stringValue";
909 int errCode = testObject.InsertField(FieldPath{"L1F1", "L2F1", "L3F1", "L4F1"}, FieldType::LEAF_FIELD_STRING, val);
910 EXPECT_TRUE(errCode == E_OK);
911 val.doubleValue = 1.1; // 1.1 for test
912 errCode = testObject.InsertField(FieldPath{"L1F1", "L2F1", "L3F1", "L4F2"}, FieldType::LEAF_FIELD_DOUBLE, val);
913 EXPECT_TRUE(errCode == E_OK);
914 val.longValue = INT64_MAX;
915 errCode = testObject.InsertField(FieldPath{"L1F1", "L2F1", "L3F2"}, FieldType::LEAF_FIELD_LONG, val);
916 EXPECT_TRUE(errCode == E_OK);
917 errCode = testObject.InsertField(FieldPath{"L1F1", "L2F2"}, FieldType::LEAF_FIELD_OBJECT, val);
918 EXPECT_TRUE(errCode == E_OK);
919 val.integerValue = INT32_MIN;
920 errCode = testObject.InsertField(FieldPath{"L1F1", "L2F2", "L3F3"}, FieldType::LEAF_FIELD_INTEGER, val);
921 EXPECT_TRUE(errCode == E_OK);
922 val.boolValue = true;
923 errCode = testObject.InsertField(FieldPath{"L1F1", "L2F2", "L3F4"}, FieldType::LEAF_FIELD_BOOL, val);
924 EXPECT_TRUE(errCode == E_OK);
925 errCode = testObject.InsertField(FieldPath{"L1F2"}, FieldType::LEAF_FIELD_NULL, val);
926 EXPECT_TRUE(errCode == E_OK);
927
928 /**
929 * @tc.steps: step2. Delete value in ValueObject
930 * @tc.expected: step2. Check delete successful
931 */
932 errCode = testObject.DeleteField(FieldPath{"L1F1", "L2F1", "L3F1", "L4F1"});
933 EXPECT_TRUE(errCode == E_OK);
934 errCode = testObject.DeleteField(FieldPath{"L1F1", "L2F1", "L3F1"});
935 EXPECT_TRUE(errCode == E_OK);
936 errCode = testObject.DeleteField(FieldPath{"L1F1"});
937 EXPECT_TRUE(errCode == E_OK);
938 }
939
940 /**
941 * @tc.name: Value Edit 002
942 * @tc.desc: Edit the value in wrong way
943 * @tc.type: FUNC
944 * @tc.require:
945 * @tc.author: xiaozhenjian
946 */
947 HWTEST_F(DistributedDBSchemaObjectTest, ValueEdit002, TestSize.Level1)
948 {
949 /**
950 * @tc.steps: step1. Insert value to ValueObject in different depth
951 * @tc.expected: step1. Check insert not successful
952 */
953 ValueObject testObject;
954 FieldValue val;
955
956 val.stringValue = "stringValue";
957 int errCode = testObject.InsertField(FieldPath{"L1F1", "L2F1", "L3F1"}, FieldType::LEAF_FIELD_STRING, val);
958 EXPECT_TRUE(errCode == E_OK);
959 val.doubleValue = 1.1; // 1.1 for test
960 errCode = testObject.InsertField(FieldPath{"L1F1", "L2F1", "L3F1"}, FieldType::LEAF_FIELD_DOUBLE, val);
961 EXPECT_TRUE(errCode != E_OK);
962 val.longValue = INT64_MAX;
963 errCode = testObject.InsertField(FieldPath{"L1F1", "L2F1", "L3F1", "L4F1"}, FieldType::LEAF_FIELD_LONG, val);
964 EXPECT_TRUE(errCode != E_OK);
965
966 /**
967 * @tc.steps: step2. Delete value in ValueObject
968 * @tc.expected: step2. Check delete not successful
969 */
970 errCode = testObject.DeleteField(FieldPath{"L1F1", "L2F1", "L3F1", "L4F1"});
971 EXPECT_TRUE(errCode != E_OK);
972 }
973
974 namespace {
CheckValueLackField(const SchemaObject & schema,const std::string & oriValue,const std::string & lackField,int expectErrCode,ValueObject & externalValueObject)975 void CheckValueLackField(const SchemaObject &schema, const std::string &oriValue, const std::string &lackField,
976 int expectErrCode, ValueObject &externalValueObject)
977 {
978 std::string valueStr = oriValue;
979 auto startIter = std::search(valueStr.begin(), valueStr.end(), lackField.begin(), lackField.end());
980 valueStr.erase(startIter, startIter + lackField.size());
981 int errCode = externalValueObject.Parse(valueStr);
982 EXPECT_EQ(errCode, E_OK);
983 errCode = schema.CheckValueAndAmendIfNeed(ValueSource::FROM_LOCAL, externalValueObject);
984 EXPECT_EQ(errCode, expectErrCode);
985 }
986
CheckValueLackField(const SchemaObject & schema,const std::string & oriValue,const std::string & lackField,int expectErrCode)987 void CheckValueLackField(const SchemaObject &schema, const std::string &oriValue, const std::string &lackField,
988 int expectErrCode)
989 {
990 ValueObject valueObj;
991 CheckValueLackField(schema, oriValue, lackField, expectErrCode, valueObj);
992 }
993 }
994
995 /**
996 * @tc.name: Value LackField 001
997 * @tc.desc: check the value which lack field
998 * @tc.type: FUNC
999 * @tc.require:
1000 * @tc.author: xiaozhenjian
1001 */
1002 HWTEST_F(DistributedDBSchemaObjectTest, ValueLackField001, TestSize.Level1)
1003 {
1004 SchemaObject schema;
1005 int errCode = schema.ParseFromSchemaString(SCHEMA_FOR_TEST_NOTNULL_AND_DEFAULT);
1006 EXPECT_EQ(errCode, E_OK);
1007
1008 /**
1009 * @tc.steps: step1. check value lack no field
1010 * @tc.expected: step1. E_VALUE_MATCH
1011 */
1012 CheckValueLackField(schema, VALUE_NO_LACK_FIELD, "", -E_VALUE_MATCH);
1013
1014 /**
1015 * @tc.steps: step2. check value lack field on no_notnull_no_default
1016 * @tc.expected: step2. E_VALUE_MATCH
1017 */
1018 CheckValueLackField(schema, VALUE_NO_LACK_FIELD, "\"no_notnull_no_default\":true,", -E_VALUE_MATCH);
1019
1020 /**
1021 * @tc.steps: step3. check value lack field on has_notnull_no_default
1022 * @tc.expected: step3. E_VALUE_MISMATCH_CONSTRAINT
1023 */
1024 CheckValueLackField(schema, VALUE_NO_LACK_FIELD, "\"has_notnull_no_default\":10010,",
1025 -E_VALUE_MISMATCH_CONSTRAINT);
1026
1027 /**
1028 * @tc.steps: step4. check value lack field on no_notnull_has_default
1029 * @tc.expected: step4. E_VALUE_MATCH_AMENDED
1030 */
1031 CheckValueLackField(schema, VALUE_NO_LACK_FIELD, "\"no_notnull_has_default\":10086,",
1032 -E_VALUE_MATCH_AMENDED);
1033
1034 /**
1035 * @tc.steps: step5. check value lack field on has_notnull_has_default
1036 * @tc.expected: step5. E_VALUE_MATCH_AMENDED
1037 */
1038 CheckValueLackField(schema, VALUE_NO_LACK_FIELD, "\"has_notnull_has_default\":1.38064,",
1039 -E_VALUE_MATCH_AMENDED);
1040
1041 /**
1042 * @tc.steps: step6. check value lack entire level_0_nest_0
1043 * @tc.expected: step6. E_VALUE_MISMATCH_CONSTRAINT
1044 */
1045 CheckValueLackField(schema, VALUE_LACK_LEVEL_0_NEST_0, "", -E_VALUE_MISMATCH_CONSTRAINT);
1046
1047 /**
1048 * @tc.steps: step7. check value level_0_nest_0 not json_object
1049 * @tc.expected: step7. E_VALUE_MISMATCH_FEILD_TYPE
1050 */
1051 CheckValueLackField(schema, VALUE_LEVEL_0_NEST_0_NOT_OBJECT, "", -E_VALUE_MISMATCH_FEILD_TYPE);
1052 }
1053
1054 /**
1055 * @tc.name: Value LackField 002
1056 * @tc.desc: check the value which lack field
1057 * @tc.type: FUNC
1058 * @tc.require:
1059 * @tc.author: xiaozhenjian
1060 */
1061 HWTEST_F(DistributedDBSchemaObjectTest, ValueLackField002, TestSize.Level1)
1062 {
1063 SchemaObject schema;
1064 int errCode = schema.ParseFromSchemaString(SCHEMA_FOR_TEST_NOTNULL_AND_DEFAULT);
1065 EXPECT_EQ(errCode, E_OK);
1066
1067 /**
1068 * @tc.steps: step1. check value lack entire level_1_nest_0
1069 * @tc.expected: step1. E_VALUE_MATCH_AMENDED
1070 */
1071 ValueObject val;
1072 CheckValueLackField(schema, VALUE_LACK_LEVEL_1_NEST_0, "", -E_VALUE_MATCH_AMENDED, val);
1073 // Check Field Existence or not
1074 EXPECT_EQ(val.IsFieldPathExist(FieldPath{"level_0_nest_0", "level_1_nest_0"}), true);
1075 EXPECT_EQ(val.IsFieldPathExist(FieldPath{"level_0_nest_0", "level_1_nest_0", "no_notnull_has_default"}), true);
1076 EXPECT_EQ(val.IsFieldPathExist(FieldPath{"level_0_nest_0", "level_1_nest_0", "has_notnull_has_default"}), true);
1077 EXPECT_EQ(val.IsFieldPathExist(FieldPath{"level_0_nest_0", "level_1_nest_0", "level_2_nest_0"}), true);
1078 EXPECT_EQ(val.IsFieldPathExist(FieldPath{"level_0_nest_0", "level_1_nest_0", "level_2_nest_0", "extra_0"}), true);
1079 EXPECT_EQ(val.IsFieldPathExist(FieldPath{"level_0_nest_0", "level_1_nest_0", "level_2_nest_0", "extra_1"}), false);
1080 EXPECT_EQ(val.IsFieldPathExist(FieldPath{"level_0_nest_0", "level_1_nest_0", "level_2_nest_0", "extra_2"}), false);
1081 EXPECT_EQ(val.IsFieldPathExist(FieldPath{"level_0_nest_0", "level_1_nest_0", "level_2_nest_1"}), false);
1082 // Check Field value
1083 FieldValue theValue;
1084 EXPECT_EQ(val.GetFieldValueByFieldPath(FieldPath{"level_0_nest_0", "level_1_nest_0", "no_notnull_has_default"},
1085 theValue), E_OK);
1086 EXPECT_EQ(theValue.integerValue, 100);
1087 EXPECT_EQ(val.GetFieldValueByFieldPath(FieldPath{"level_0_nest_0", "level_1_nest_0", "has_notnull_has_default"},
1088 theValue), E_OK);
1089 EXPECT_LT(std::abs(theValue.doubleValue - 3.14), 0.1);
1090 EXPECT_EQ(val.GetFieldValueByFieldPath(FieldPath{"level_0_nest_0", "level_1_nest_0", "level_2_nest_0", "extra_0"},
1091 theValue), E_OK);
1092 EXPECT_EQ(theValue.stringValue == std::string("3.1415"), true);
1093 }
1094
1095 /**
1096 * @tc.name: SchemaObjectErrTest
1097 * @tc.desc: Parse Schema Object err scene
1098 * @tc.type: FUNC
1099 * @tc.require:
1100 * @tc.author: suyue
1101 */
1102 HWTEST_F(DistributedDBSchemaObjectTest, SchemaObjectErrTest001, TestSize.Level1)
1103 {
1104 /**
1105 * @tc.steps: step1. Call GetExtractFuncName interface with NONE SchemaType.
1106 * @tc.expected: step1. Get non-JSON string.
1107 */
1108 SchemaObject schema;
1109 std::string str1 = schema.GetExtractFuncName(SchemaType::NONE);
1110 const std::string expectStr1 = "flatbuffer_extract_by_path";
1111 EXPECT_TRUE(str1.compare(0, expectStr1.length(), expectStr1) == 0);
1112
1113 /**
1114 * @tc.steps: step2. Call interfaces with empty FieldPath.
1115 * @tc.expected: step2. return -E_INVALID_ARGS.
1116 */
1117 FieldPath inFieldpath1 = {};
1118 std::string str2 = schema.GenerateExtractSQL(SchemaType::JSON, inFieldpath1, FieldType::LEAF_FIELD_BOOL, 0, "");
1119 const std::string expectStr2 = "";
1120 EXPECT_TRUE(str2.compare(0, expectStr2.length(), "") == 0);
1121 FieldType schemaFieldType = FieldType::LEAF_FIELD_BOOL;
1122 int ret = schema.CheckQueryableAndGetFieldType(inFieldpath1, schemaFieldType);
1123 EXPECT_EQ(ret, -E_INVALID_ARGS);
1124
1125 /**
1126 * @tc.steps: step3. Call interfaces with LEAF_FIELD_NULL FieldType.
1127 * @tc.expected: step3. return -E_NOT_FOUND.
1128 */
1129 FieldPath inFieldpath2 = {"test"};
1130 str2 = schema.GenerateExtractSQL(SchemaType::JSON, inFieldpath2, FieldType::LEAF_FIELD_NULL, 0, "");
1131 EXPECT_TRUE(str2.compare(0, expectStr2.length(), "") == 0);
1132 ret = schema.CheckQueryableAndGetFieldType(inFieldpath2, schemaFieldType);
1133 EXPECT_EQ(ret, -E_NOT_FOUND);
1134 }
1135
1136 /**
1137 * @tc.name: SchemaObjectErrTest002
1138 * @tc.desc: Parse Schema Object err scene
1139 * @tc.type: FUNC
1140 * @tc.require:
1141 * @tc.author: suyue
1142 */
1143 HWTEST_F(DistributedDBSchemaObjectTest, SchemaObjectErrTest002, TestSize.Level1)
1144 {
1145 /**
1146 * @tc.steps: step1. Call interfaces without Schema Parse.
1147 * @tc.expected: step1. return -E_NOT_PERMIT.
1148 */
1149 SchemaObject schema;
1150 IndexDifference indexDiffer;
1151 int ret = schema.CompareAgainstSchemaObject(schema, indexDiffer);
1152 EXPECT_EQ(ret, -E_NOT_PERMIT);
1153 ValueObject inValue;
1154 ret = schema.CheckValueAndAmendIfNeed(ValueSource::FROM_LOCAL, inValue);
1155 EXPECT_EQ(ret, -E_NOT_PERMIT);
1156
1157 const Value val = {0};
1158 ret = schema.VerifyValue(ValueSource::FROM_LOCAL, val);
1159 EXPECT_EQ(ret, -E_NOT_PERMIT);
1160
1161 /**
1162 * @tc.steps: step2. Call VerifyValue interface when RawValue first para is nullptr.
1163 * @tc.expected: step2. return -E_INVALID_ARGS.
1164 */
1165 ret = schema.VerifyValue(ValueSource::FROM_LOCAL, RawValue{nullptr, 0});
1166 EXPECT_EQ(ret, -E_INVALID_ARGS);
1167
1168 /**
1169 * @tc.steps: step3. Parse twice same schema.
1170 * @tc.expected: step3. second return -E_NOT_PERMIT.
1171 */
1172 SchemaObject schema1;
1173 int stepOne = schema1.ParseFromSchemaString(VALID_SCHEMA_FULL_DEFINE);
1174 EXPECT_EQ(stepOne, E_OK);
1175 stepOne = schema1.ParseFromSchemaString(VALID_SCHEMA_FULL_DEFINE);
1176 EXPECT_EQ(stepOne, -E_NOT_PERMIT);
1177 }
1178 #endif