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.begin(), SchemaConstant::KEYWORD_MODE_STRICT.end());
387 auto iterForCompatible = std::search(resultSchemaStr.begin(), resultSchemaStr.end(),
388 SchemaConstant::KEYWORD_MODE_COMPATIBLE.begin(), SchemaConstant::KEYWORD_MODE_COMPATIBLE.end());
389 if (iterForStrict != resultSchemaStr.end()) {
390 resultSchemaStr.replace(iterForStrict, iterForStrict + SchemaConstant::KEYWORD_MODE_STRICT.size(),
391 SchemaConstant::KEYWORD_MODE_COMPATIBLE.begin(), SchemaConstant::KEYWORD_MODE_COMPATIBLE.end());
392 return resultSchemaStr;
393 }
394 if (iterForCompatible != resultSchemaStr.end()) {
395 resultSchemaStr.replace(iterForCompatible, iterForCompatible + SchemaConstant::KEYWORD_MODE_COMPATIBLE.size(),
396 SchemaConstant::KEYWORD_MODE_STRICT.begin(), SchemaConstant::KEYWORD_MODE_STRICT.end());
397 return resultSchemaStr;
398 }
399 return oriSchemaStr;
400 }
401 }
402
403 class DistributedDBSchemaObjectTest : public testing::Test {
404 public:
SetUpTestCase(void)405 static void SetUpTestCase(void) {};
TearDownTestCase(void)406 static void TearDownTestCase(void) {};
407 void SetUp() override;
TearDown()408 void TearDown() override {};
409 };
410
SetUp()411 void DistributedDBSchemaObjectTest::SetUp()
412 {
413 DistributedDBUnitTest::DistributedDBToolsUnitTest::PrintTestCaseInfo();
414 }
415
416 /**
417 * @tc.name: Parse Valid Schema 001
418 * @tc.desc: Parse Valid Schema
419 * @tc.type: FUNC
420 * @tc.require: AR000DR9K3
421 * @tc.author: xiaozhenjian
422 */
423 HWTEST_F(DistributedDBSchemaObjectTest, ParseValidSchema001, TestSize.Level1)
424 {
425 /**
426 * @tc.steps: step1. Parse valid schema with full define
427 * @tc.expected: step1. Parse Success.
428 */
429 SchemaObject schema1;
430 int stepOne = schema1.ParseFromSchemaString(VALID_SCHEMA_FULL_DEFINE);
431 EXPECT_TRUE(stepOne == E_OK);
432
433 /**
434 * @tc.steps: step2. Parse valid schema with empty index
435 * @tc.expected: step2. Parse Success.
436 */
437 SchemaObject schema2;
438 int stepTwo = schema2.ParseFromSchemaString(VALID_SCHEMA_INDEX_EMPTY);
439 EXPECT_TRUE(stepTwo == E_OK);
440
441 /**
442 * @tc.steps: step3. Parse valid schema with no index field
443 * @tc.expected: step3. Parse Success.
444 */
445 SchemaObject schema3;
446 int stepThree = schema3.ParseFromSchemaString(VALID_SCHEMA_NO_INDEX);
447 EXPECT_TRUE(stepThree == E_OK);
448
449 /**
450 * @tc.steps: step4. Parse valid schema with prefix of suffix blank
451 * @tc.expected: step4. Parse Success.
452 */
453 SchemaObject schema4;
454 int stepFour = schema4.ParseFromSchemaString(VALID_SCHEMA_PRE_SUF_BLANK);
455 EXPECT_TRUE(stepFour == E_OK);
456 }
457
458 /**
459 * @tc.name: Parse Invalid Schema 001
460 * @tc.desc: Parse Invalid Schema
461 * @tc.type: FUNC
462 * @tc.require: AR000DR9K3
463 * @tc.author: xiaozhenjian
464 */
465 HWTEST_F(DistributedDBSchemaObjectTest, ParseInvalidSchema001, TestSize.Level1)
466 {
467 /**
468 * @tc.steps: step1. Parse invalid schema which is not valid json
469 * @tc.expected: step1. Parse Fail.
470 */
471 SchemaObject schema1;
472 int stepOne = schema1.ParseFromSchemaString(INVALID_SCHEMA_INVALID_JSON);
473 EXPECT_TRUE(stepOne != E_OK);
474
475 /**
476 * @tc.steps: step2. Parse invalid schema with less field in depth 0
477 * @tc.expected: step2. Parse Fail.
478 */
479 SchemaObject schema2;
480 int stepTwo = schema2.ParseFromSchemaString(INVALID_SCHEMA_LESS_META_FIELD);
481 EXPECT_TRUE(stepTwo != E_OK);
482
483 /**
484 * @tc.steps: step3. Parse invalid schema with more field in depth 0
485 * @tc.expected: step3. Parse Fail.
486 */
487 SchemaObject schema3;
488 int stepThree = schema3.ParseFromSchemaString(INVALID_SCHEMA_MORE_META_FIELD);
489 EXPECT_TRUE(stepThree != E_OK);
490
491 /**
492 * @tc.steps: step4. Parse invalid schema with wrong version
493 * @tc.expected: step4. Parse Fail.
494 */
495 SchemaObject schema4;
496 int stepFour = schema4.ParseFromSchemaString(INVALID_SCHEMA_WRONG_VERSION);
497 EXPECT_TRUE(stepFour != E_OK);
498
499 /**
500 * @tc.steps: step5. Parse invalid schema with wrong mode
501 * @tc.expected: step5. Parse Fail.
502 */
503 SchemaObject schema5;
504 int stepFive = schema5.ParseFromSchemaString(INVALID_SCHEMA_WRONG_MODE);
505 EXPECT_TRUE(stepFive != E_OK);
506 }
507
508 /**
509 * @tc.name: Parse Invalid Schema 002
510 * @tc.desc: Parse Invalid Schema
511 * @tc.type: FUNC
512 * @tc.require: AR000DR9K3
513 * @tc.author: xiaozhenjian
514 */
515 HWTEST_F(DistributedDBSchemaObjectTest, ParseInvalidSchema002, TestSize.Level1)
516 {
517 /**
518 * @tc.steps: step1. Parse invalid schema which is empty define
519 * @tc.expected: step1. Parse Fail.
520 */
521 SchemaObject schema1;
522 int stepOne = schema1.ParseFromSchemaString(INVALID_SCHEMA_DEFINE_EMPTY);
523 EXPECT_TRUE(stepOne != E_OK);
524
525 /**
526 * @tc.steps: step2. Parse invalid schema with define nest too deep
527 * @tc.expected: step2. Parse Fail.
528 */
529 SchemaObject schema2;
530 int stepTwo = schema2.ParseFromSchemaString(INVALID_SCHEMA_DEFINE_NEST_TOO_DEEP);
531 EXPECT_TRUE(stepTwo != E_OK);
532
533 /**
534 * @tc.steps: step3. Parse invalid schema with invalid fieldname in define
535 * @tc.expected: step3. Parse Fail.
536 */
537 SchemaObject schema3;
538 int stepThree = schema3.ParseFromSchemaString(INVALID_SCHEMA_DEFINE_INVALID_FIELD_NAME);
539 EXPECT_TRUE(stepThree != E_OK);
540
541 /**
542 * @tc.steps: step4. Parse invalid schema with invalid field attribute in define
543 * @tc.expected: step4. Parse Fail.
544 */
545 SchemaObject schema4;
546 int stepFour = schema4.ParseFromSchemaString(INVALID_SCHEMA_DEFINE_INVALID_FIELD_ATTR);
547 EXPECT_TRUE(stepFour != E_OK);
548
549 /**
550 * @tc.steps: step5. Parse invalid schema with not empty array in define
551 * @tc.expected: step5. Parse Fail.
552 */
553 SchemaObject schema5;
554 int stepFive = schema5.ParseFromSchemaString(INVALID_SCHEMA_DEFINE_INVALID_ARRAY_TYPE);
555 EXPECT_TRUE(stepFive != E_OK);
556 }
557
558 /**
559 * @tc.name: Parse Invalid Schema 003
560 * @tc.desc: Parse Invalid Schema
561 * @tc.type: FUNC
562 * @tc.require: AR000DR9K3
563 * @tc.author: xiaozhenjian
564 */
565 HWTEST_F(DistributedDBSchemaObjectTest, ParseInvalidSchema003, TestSize.Level1)
566 {
567 /**
568 * @tc.steps: step1. Parse invalid schema with invalid array content
569 * @tc.expected: step1. Parse Fail.
570 */
571 SchemaObject schema1;
572 int stepOne = schema1.ParseFromSchemaString(INVALID_SCHEMA_INDEX_INVALID);
573 EXPECT_TRUE(stepOne != E_OK);
574
575 /**
576 * @tc.steps: step2. Parse invalid schema with invalid path
577 * @tc.expected: step2. Parse Fail.
578 */
579 SchemaObject schema2;
580 int stepTwo = schema2.ParseFromSchemaString(INVALID_SCHEMA_INDEX_PATH_INVALID);
581 EXPECT_TRUE(stepTwo != E_OK);
582
583 /**
584 * @tc.steps: step3. Parse invalid schema with path not exist
585 * @tc.expected: step3. Parse Fail.
586 */
587 SchemaObject schema3;
588 int stepThree = schema3.ParseFromSchemaString(INVALID_SCHEMA_INDEX_PATH_NOT_EXIST);
589 EXPECT_TRUE(stepThree != E_OK);
590
591 /**
592 * @tc.steps: step4. Parse invalid schema with path not indexable
593 * @tc.expected: step4. Parse Fail.
594 */
595 SchemaObject schema4;
596 int stepFour = schema4.ParseFromSchemaString(INVALID_SCHEMA_INDEX_PATH_NOT_INDEXABLE);
597 EXPECT_TRUE(stepFour != E_OK);
598
599 /**
600 * @tc.steps: step5. Parse invalid schema with duplicate
601 * @tc.expected: step5. Parse Fail.
602 */
603 SchemaObject schema5;
604 int stepFive = schema5.ParseFromSchemaString(INVALID_SCHEMA_INDEX_PATH_DUPLICATE);
605 EXPECT_TRUE(stepFive != E_OK);
606 }
607
608 /**
609 * @tc.name: Compare Equal Exactly 001
610 * @tc.desc: Compare Equal Exactly
611 * @tc.type: FUNC
612 * @tc.require: AR000DR9K4
613 * @tc.author: xiaozhenjian
614 */
615 HWTEST_F(DistributedDBSchemaObjectTest, CompareEqualExactly001, TestSize.Level1)
616 {
617 SchemaObject schemaOri;
618 int errCode = schemaOri.ParseFromSchemaString(VALID_SCHEMA_FULL_DEFINE);
619 EXPECT_TRUE(errCode == E_OK);
620
621 /**
622 * @tc.steps: step1. Compare two same schema with full define
623 * @tc.expected: step1. Equal exactly.
624 */
625 int stepOne = schemaOri.CompareAgainstSchemaString(VALID_SCHEMA_FULL_DEFINE);
626 EXPECT_TRUE(stepOne == -E_SCHEMA_EQUAL_EXACTLY);
627 }
628
629 /**
630 * @tc.name: Compare Unequal Compatible 001
631 * @tc.desc: Compare Unequal Compatible
632 * @tc.type: FUNC
633 * @tc.require: AR000DR9K4
634 * @tc.author: xiaozhenjian
635 */
636 HWTEST_F(DistributedDBSchemaObjectTest, CompareUnequalCompatible001, TestSize.Level1)
637 {
638 SchemaObject compatibleSchema;
639 int errCode = compatibleSchema.ParseFromSchemaString(SCHEMA_COMPARE_BASELINE);
640 EXPECT_EQ(errCode, E_OK);
641
642 /**
643 * @tc.steps: step1. new schema index more
644 * @tc.expected: step1. E_SCHEMA_UNEQUAL_COMPATIBLE.
645 */
646 errCode = compatibleSchema.CompareAgainstSchemaString(SCHEMA_INDEX_MORE);
647 EXPECT_EQ(errCode, -E_SCHEMA_UNEQUAL_COMPATIBLE);
648
649 /**
650 * @tc.steps: step2. new schema index less
651 * @tc.expected: step2. E_SCHEMA_UNEQUAL_COMPATIBLE.
652 */
653 errCode = compatibleSchema.CompareAgainstSchemaString(SCHEMA_INDEX_LESS);
654 EXPECT_EQ(errCode, -E_SCHEMA_UNEQUAL_COMPATIBLE);
655
656 /**
657 * @tc.steps: step3. new schema index change
658 * @tc.expected: step3. E_SCHEMA_UNEQUAL_COMPATIBLE.
659 */
660 errCode = compatibleSchema.CompareAgainstSchemaString(SCHEMA_INDEX_CHANGE);
661 EXPECT_EQ(errCode, -E_SCHEMA_UNEQUAL_COMPATIBLE);
662 }
663
664 /**
665 * @tc.name: Compare Unequal Compatible Upgrade 001
666 * @tc.desc: Compare Unequal Compatible Upgrade
667 * @tc.type: FUNC
668 * @tc.require: AR000DR9K4
669 * @tc.author: xiaozhenjian
670 */
671 HWTEST_F(DistributedDBSchemaObjectTest, CompareUnequalCompatibleUpgrade001, TestSize.Level1)
672 {
673 SchemaObject compatibleSchema;
674 int errCode = compatibleSchema.ParseFromSchemaString(SCHEMA_COMPARE_BASELINE);
675 EXPECT_EQ(errCode, E_OK);
676
677 /**
678 * @tc.steps: step1. compatible new schema more field define
679 * @tc.expected: step1. E_SCHEMA_UNEQUAL_COMPATIBLE_UPGRADE.
680 */
681 errCode = compatibleSchema.CompareAgainstSchemaString(SCHEMA_DEFINE_MORE_FIELD);
682 EXPECT_EQ(errCode, -E_SCHEMA_UNEQUAL_COMPATIBLE_UPGRADE);
683
684 /**
685 * @tc.steps: step2. compatible new schema more field with not null and default
686 * @tc.expected: step2. E_SCHEMA_UNEQUAL_COMPATIBLE_UPGRADE.
687 */
688 errCode = compatibleSchema.CompareAgainstSchemaString(SCHEMA_DEFINE_MORE_FIELD_NOTNULL_PERMIT);
689 EXPECT_EQ(errCode, -E_SCHEMA_UNEQUAL_COMPATIBLE_UPGRADE);
690
691 /**
692 * @tc.steps: step3. compatible new schema more field and more index
693 * @tc.expected: step3. E_SCHEMA_UNEQUAL_COMPATIBLE_UPGRADE.
694 */
695 errCode = compatibleSchema.CompareAgainstSchemaString(SCHEMA_DEFINE_MORE_FIELD_MORE_INDEX);
696 EXPECT_EQ(errCode, -E_SCHEMA_UNEQUAL_COMPATIBLE_UPGRADE);
697 }
698
699 /**
700 * @tc.name: Compare Unequal Incompatible 001
701 * @tc.desc: Compare Unequal Incompatible
702 * @tc.type: FUNC
703 * @tc.require: AR000DR9K4
704 * @tc.author: xiaozhenjian
705 */
706 HWTEST_F(DistributedDBSchemaObjectTest, CompareUnequalIncompatible001, TestSize.Level1)
707 {
708 SchemaObject strictSchema;
709 int errCode = strictSchema.ParseFromSchemaString(SchemaSwitchMode(SCHEMA_COMPARE_BASELINE));
710 EXPECT_EQ(errCode, E_OK);
711 SchemaObject compatibleSchema;
712 errCode = compatibleSchema.ParseFromSchemaString(SCHEMA_COMPARE_BASELINE);
713 EXPECT_EQ(errCode, E_OK);
714
715 /**
716 * @tc.steps: step1. strict new schema more field define
717 * @tc.expected: step1. E_SCHEMA_UNEQUAL_INCOMPATIBLE.
718 */
719 errCode = strictSchema.CompareAgainstSchemaString(SchemaSwitchMode(SCHEMA_DEFINE_MORE_FIELD));
720 EXPECT_EQ(errCode, -E_SCHEMA_UNEQUAL_INCOMPATIBLE);
721
722 /**
723 * @tc.steps: step2. compatible new schema more field but not null
724 * @tc.expected: step2. E_SCHEMA_UNEQUAL_INCOMPATIBLE.
725 */
726 errCode = compatibleSchema.CompareAgainstSchemaString(SCHEMA_DEFINE_MORE_FIELD_NOTNULL_FORBID);
727 EXPECT_EQ(errCode, -E_SCHEMA_UNEQUAL_INCOMPATIBLE);
728
729 /**
730 * @tc.steps: step3. new schema less field
731 * @tc.expected: step3. E_SCHEMA_UNEQUAL_INCOMPATIBLE.
732 */
733 errCode = compatibleSchema.CompareAgainstSchemaString(SCHEMA_DEFINE_LESS_FIELD);
734 EXPECT_EQ(errCode, -E_SCHEMA_UNEQUAL_INCOMPATIBLE);
735 errCode = strictSchema.CompareAgainstSchemaString(SchemaSwitchMode(SCHEMA_DEFINE_LESS_FIELD));
736 EXPECT_EQ(errCode, -E_SCHEMA_UNEQUAL_INCOMPATIBLE);
737
738 /**
739 * @tc.steps: step4. new schema skipsize differ
740 * @tc.expected: step4. E_SCHEMA_UNEQUAL_INCOMPATIBLE.
741 */
742 errCode = compatibleSchema.CompareAgainstSchemaString(SCHEMA_SKIPSIZE_DIFFER);
743 EXPECT_EQ(errCode, -E_SCHEMA_UNEQUAL_INCOMPATIBLE);
744
745 /**
746 * @tc.steps: step5. new schema type differ
747 * @tc.expected: step5. E_SCHEMA_UNEQUAL_INCOMPATIBLE.
748 */
749 errCode = compatibleSchema.CompareAgainstSchemaString(SCHEMA_DEFINE_TYPE_DIFFER);
750 EXPECT_EQ(errCode, -E_SCHEMA_UNEQUAL_INCOMPATIBLE);
751
752 /**
753 * @tc.steps: step6. new schema notnull differ
754 * @tc.expected: step6. E_SCHEMA_UNEQUAL_INCOMPATIBLE.
755 */
756 errCode = compatibleSchema.CompareAgainstSchemaString(SCHEMA_DEFINE_NOTNULL_DIFFER);
757 EXPECT_EQ(errCode, -E_SCHEMA_UNEQUAL_INCOMPATIBLE);
758
759 /**
760 * @tc.steps: step7. new schema default differ
761 * @tc.expected: step7. E_SCHEMA_UNEQUAL_INCOMPATIBLE.
762 */
763 errCode = compatibleSchema.CompareAgainstSchemaString(SCHEMA_DEFINE_DEFAULT_DIFFER);
764 EXPECT_EQ(errCode, -E_SCHEMA_UNEQUAL_INCOMPATIBLE);
765
766 /**
767 * @tc.steps: step8. new schema mode differ
768 * @tc.expected: step8. E_SCHEMA_UNEQUAL_INCOMPATIBLE.
769 */
770 errCode = compatibleSchema.CompareAgainstSchemaString(SchemaSwitchMode(SCHEMA_COMPARE_BASELINE));
771 EXPECT_EQ(errCode, -E_SCHEMA_UNEQUAL_INCOMPATIBLE);
772 }
773
774 /**
775 * @tc.name: Check Value 001
776 * @tc.desc: Check value both in strict and compatible mode
777 * @tc.type: FUNC
778 * @tc.require: AR000DR9K5
779 * @tc.author: xiaozhenjian
780 */
781 HWTEST_F(DistributedDBSchemaObjectTest, CheckValue001, TestSize.Level1)
782 {
783 SchemaObject schemaStrict;
784 int errCode = schemaStrict.ParseFromSchemaString(VALID_SCHEMA_FULL_DEFINE);
785 EXPECT_TRUE(errCode == E_OK);
786
787 /**
788 * @tc.steps: step1. value has less field in strict mode
789 * @tc.expected: step1. E_VALUE_MATCH_AMENDED.
790 */
791 ValueObject value1;
792 errCode = value1.Parse(VALUE_LESS_FIELD);
793 EXPECT_TRUE(errCode == E_OK);
794 int stepOne = schemaStrict.CheckValueAndAmendIfNeed(ValueSource::FROM_LOCAL, value1);
795 EXPECT_TRUE(stepOne == -E_VALUE_MATCH_AMENDED);
796
797 /**
798 * @tc.steps: step2. value has more field in strict mode
799 * @tc.expected: step2. E_VALUE_MISMATCH_FEILD_COUNT.
800 */
801 ValueObject value2;
802 errCode = value2.Parse(VALUE_MORE_FIELD);
803 EXPECT_TRUE(errCode == E_OK);
804 int stepTwo = schemaStrict.CheckValueAndAmendIfNeed(ValueSource::FROM_LOCAL, value2);
805 EXPECT_TRUE(stepTwo == -E_VALUE_MISMATCH_FEILD_COUNT);
806
807 /**
808 * @tc.steps: step3. value type mismatch
809 * @tc.expected: step3. E_VALUE_MISMATCH_FEILD_TYPE.
810 */
811 ValueObject value3;
812 errCode = value3.Parse(VALUE_TYPE_MISMATCH);
813 EXPECT_TRUE(errCode == E_OK);
814 int stepThree = schemaStrict.CheckValueAndAmendIfNeed(ValueSource::FROM_LOCAL, value3);
815 EXPECT_TRUE(stepThree == -E_VALUE_MISMATCH_FEILD_TYPE);
816
817 /**
818 * @tc.steps: step4. value not null violation
819 * @tc.expected: step4. E_VALUE_MISMATCH_CONSTRAINT.
820 */
821 ValueObject value4;
822 errCode = value4.Parse(VALUE_NOT_NULL_VIOLATION);
823 EXPECT_TRUE(errCode == E_OK);
824 int stepFour = schemaStrict.CheckValueAndAmendIfNeed(ValueSource::FROM_LOCAL, value4);
825 EXPECT_TRUE(stepFour == -E_VALUE_MISMATCH_CONSTRAINT);
826
827 /**
828 * @tc.steps: step5. value exactly match strict mode
829 * @tc.expected: step5. E_VALUE_MATCH.
830 */
831 ValueObject value5;
832 errCode = value5.Parse(VALUE_MATCH_STRICT_SCHEMA);
833 EXPECT_TRUE(errCode == E_OK);
834 int stepFive = schemaStrict.CheckValueAndAmendIfNeed(ValueSource::FROM_LOCAL, value5);
835 EXPECT_TRUE(stepFive == -E_VALUE_MATCH);
836
837 /**
838 * @tc.steps: step6. value has more field in compatible mode
839 * @tc.expected: step6. E_VALUE_MATCH.
840 */
841 std::string compatibleSchemaString = SchemaSwitchMode(VALID_SCHEMA_FULL_DEFINE);
842 SchemaObject schemaCompatible;
843 errCode = schemaCompatible.ParseFromSchemaString(compatibleSchemaString);
844 EXPECT_TRUE(errCode == E_OK);
845
846 ValueObject value6;
847 std::vector<uint8_t> moreFieldValueVector(VALUE_MORE_FIELD.begin(), VALUE_MORE_FIELD.end());
848 errCode = value6.Parse(moreFieldValueVector);
849 EXPECT_TRUE(errCode == E_OK);
850 int stepSix = schemaCompatible.CheckValueAndAmendIfNeed(ValueSource::FROM_LOCAL, value6);
851 EXPECT_TRUE(stepSix == -E_VALUE_MATCH);
852 }
853
854 /**
855 * @tc.name: Check Value 002
856 * @tc.desc: Check value that has offset
857 * @tc.type: FUNC
858 * @tc.require: AR000DR9K5
859 * @tc.author: xiaozhenjian
860 */
861 HWTEST_F(DistributedDBSchemaObjectTest, CheckValue002, TestSize.Level1)
862 {
863 SchemaObject schemaStrict;
864 int errCode = schemaStrict.ParseFromSchemaString(VALID_SCHEMA_FULL_DEFINE);
865 EXPECT_TRUE(errCode == E_OK);
866
867 /**
868 * @tc.steps: step1. value has less field in strict mode
869 * @tc.expected: step1. E_VALUE_MATCH and data before offset not change.
870 */
871 std::string beforeOffset = "BOM_CONTENT:";
872 std::string strValue = beforeOffset + VALUE_MATCH_STRICT_SCHEMA;
873 vector<uint8_t> vecValue(strValue.begin(), strValue.end());
874
875 ValueObject value1;
876 errCode = value1.Parse(vecValue.data(), vecValue.data() + vecValue.size(), beforeOffset.size());
877 EXPECT_TRUE(errCode == E_OK);
878
879 int stepOne = schemaStrict.CheckValueAndAmendIfNeed(ValueSource::FROM_LOCAL, value1);
880 EXPECT_TRUE(stepOne == -E_VALUE_MATCH);
881
882 std::string valueToString = value1.ToString();
883 EXPECT_EQ(strValue.size(), valueToString.size());
884 std::string valueBeforeOffset = valueToString.substr(0, beforeOffset.size());
885 EXPECT_EQ(valueBeforeOffset, beforeOffset);
886 }
887
888 /**
889 * @tc.name: Value Edit 001
890 * @tc.desc: Edit the value in right way
891 * @tc.type: FUNC
892 * @tc.require: AR000DR9K5
893 * @tc.author: xiaozhenjian
894 */
895 HWTEST_F(DistributedDBSchemaObjectTest, ValueEdit001, TestSize.Level1)
896 {
897 /**
898 * @tc.steps: step1. Insert value to ValueObject in different depth
899 * @tc.expected: step1. Check insert successful
900 */
901 ValueObject testObject;
902 FieldValue val;
903
904 val.stringValue = "stringValue";
905 int errCode = testObject.InsertField(FieldPath{"L1F1", "L2F1", "L3F1", "L4F1"}, FieldType::LEAF_FIELD_STRING, val);
906 EXPECT_TRUE(errCode == E_OK);
907 val.doubleValue = 1.1; // 1.1 for test
908 errCode = testObject.InsertField(FieldPath{"L1F1", "L2F1", "L3F1", "L4F2"}, FieldType::LEAF_FIELD_DOUBLE, val);
909 EXPECT_TRUE(errCode == E_OK);
910 val.longValue = INT64_MAX;
911 errCode = testObject.InsertField(FieldPath{"L1F1", "L2F1", "L3F2"}, FieldType::LEAF_FIELD_LONG, val);
912 EXPECT_TRUE(errCode == E_OK);
913 errCode = testObject.InsertField(FieldPath{"L1F1", "L2F2"}, FieldType::LEAF_FIELD_OBJECT, val);
914 EXPECT_TRUE(errCode == E_OK);
915 val.integerValue = INT32_MIN;
916 errCode = testObject.InsertField(FieldPath{"L1F1", "L2F2", "L3F3"}, FieldType::LEAF_FIELD_INTEGER, val);
917 EXPECT_TRUE(errCode == E_OK);
918 val.boolValue = true;
919 errCode = testObject.InsertField(FieldPath{"L1F1", "L2F2", "L3F4"}, FieldType::LEAF_FIELD_BOOL, val);
920 EXPECT_TRUE(errCode == E_OK);
921 errCode = testObject.InsertField(FieldPath{"L1F2"}, FieldType::LEAF_FIELD_NULL, val);
922 EXPECT_TRUE(errCode == E_OK);
923
924 /**
925 * @tc.steps: step2. Delete value in ValueObject
926 * @tc.expected: step2. Check delete successful
927 */
928 errCode = testObject.DeleteField(FieldPath{"L1F1", "L2F1", "L3F1", "L4F1"});
929 EXPECT_TRUE(errCode == E_OK);
930 errCode = testObject.DeleteField(FieldPath{"L1F1", "L2F1", "L3F1"});
931 EXPECT_TRUE(errCode == E_OK);
932 errCode = testObject.DeleteField(FieldPath{"L1F1"});
933 EXPECT_TRUE(errCode == E_OK);
934 }
935
936 /**
937 * @tc.name: Value Edit 002
938 * @tc.desc: Edit the value in wrong way
939 * @tc.type: FUNC
940 * @tc.require: AR000DR9K5
941 * @tc.author: xiaozhenjian
942 */
943 HWTEST_F(DistributedDBSchemaObjectTest, ValueEdit002, TestSize.Level1)
944 {
945 /**
946 * @tc.steps: step1. Insert value to ValueObject in different depth
947 * @tc.expected: step1. Check insert not successful
948 */
949 ValueObject testObject;
950 FieldValue val;
951
952 val.stringValue = "stringValue";
953 int errCode = testObject.InsertField(FieldPath{"L1F1", "L2F1", "L3F1"}, FieldType::LEAF_FIELD_STRING, val);
954 EXPECT_TRUE(errCode == E_OK);
955 val.doubleValue = 1.1; // 1.1 for test
956 errCode = testObject.InsertField(FieldPath{"L1F1", "L2F1", "L3F1"}, FieldType::LEAF_FIELD_DOUBLE, val);
957 EXPECT_TRUE(errCode != E_OK);
958 val.longValue = INT64_MAX;
959 errCode = testObject.InsertField(FieldPath{"L1F1", "L2F1", "L3F1", "L4F1"}, FieldType::LEAF_FIELD_LONG, val);
960 EXPECT_TRUE(errCode != E_OK);
961
962 /**
963 * @tc.steps: step2. Delete value in ValueObject
964 * @tc.expected: step2. Check delete not successful
965 */
966 errCode = testObject.DeleteField(FieldPath{"L1F1", "L2F1", "L3F1", "L4F1"});
967 EXPECT_TRUE(errCode != E_OK);
968 }
969
970 namespace {
CheckValueLackField(const SchemaObject & schema,const std::string & oriValue,const std::string & lackField,int expectErrCode,ValueObject & externalValueObject)971 void CheckValueLackField(const SchemaObject &schema, const std::string &oriValue, const std::string &lackField,
972 int expectErrCode, ValueObject &externalValueObject)
973 {
974 std::string valueStr = oriValue;
975 auto startIter = std::search(valueStr.begin(), valueStr.end(), lackField.begin(), lackField.end());
976 valueStr.erase(startIter, startIter + lackField.size());
977 int errCode = externalValueObject.Parse(valueStr);
978 EXPECT_EQ(errCode, E_OK);
979 errCode = schema.CheckValueAndAmendIfNeed(ValueSource::FROM_LOCAL, externalValueObject);
980 EXPECT_EQ(errCode, expectErrCode);
981 }
982
CheckValueLackField(const SchemaObject & schema,const std::string & oriValue,const std::string & lackField,int expectErrCode)983 void CheckValueLackField(const SchemaObject &schema, const std::string &oriValue, const std::string &lackField,
984 int expectErrCode)
985 {
986 ValueObject valueObj;
987 CheckValueLackField(schema, oriValue, lackField, expectErrCode, valueObj);
988 }
989 }
990
991 /**
992 * @tc.name: Value LackField 001
993 * @tc.desc: check the value which lack field
994 * @tc.type: FUNC
995 * @tc.require: AR000DR9K5
996 * @tc.author: xiaozhenjian
997 */
998 HWTEST_F(DistributedDBSchemaObjectTest, ValueLackField001, TestSize.Level1)
999 {
1000 SchemaObject schema;
1001 int errCode = schema.ParseFromSchemaString(SCHEMA_FOR_TEST_NOTNULL_AND_DEFAULT);
1002 EXPECT_EQ(errCode, E_OK);
1003
1004 /**
1005 * @tc.steps: step1. check value lack no field
1006 * @tc.expected: step1. E_VALUE_MATCH
1007 */
1008 CheckValueLackField(schema, VALUE_NO_LACK_FIELD, "", -E_VALUE_MATCH);
1009
1010 /**
1011 * @tc.steps: step2. check value lack field on no_notnull_no_default
1012 * @tc.expected: step2. E_VALUE_MATCH
1013 */
1014 CheckValueLackField(schema, VALUE_NO_LACK_FIELD, "\"no_notnull_no_default\":true,", -E_VALUE_MATCH);
1015
1016 /**
1017 * @tc.steps: step3. check value lack field on has_notnull_no_default
1018 * @tc.expected: step3. E_VALUE_MISMATCH_CONSTRAINT
1019 */
1020 CheckValueLackField(schema, VALUE_NO_LACK_FIELD, "\"has_notnull_no_default\":10010,",
1021 -E_VALUE_MISMATCH_CONSTRAINT);
1022
1023 /**
1024 * @tc.steps: step4. check value lack field on no_notnull_has_default
1025 * @tc.expected: step4. E_VALUE_MATCH_AMENDED
1026 */
1027 CheckValueLackField(schema, VALUE_NO_LACK_FIELD, "\"no_notnull_has_default\":10086,",
1028 -E_VALUE_MATCH_AMENDED);
1029
1030 /**
1031 * @tc.steps: step5. check value lack field on has_notnull_has_default
1032 * @tc.expected: step5. E_VALUE_MATCH_AMENDED
1033 */
1034 CheckValueLackField(schema, VALUE_NO_LACK_FIELD, "\"has_notnull_has_default\":1.38064,",
1035 -E_VALUE_MATCH_AMENDED);
1036
1037 /**
1038 * @tc.steps: step6. check value lack entire level_0_nest_0
1039 * @tc.expected: step6. E_VALUE_MISMATCH_CONSTRAINT
1040 */
1041 CheckValueLackField(schema, VALUE_LACK_LEVEL_0_NEST_0, "", -E_VALUE_MISMATCH_CONSTRAINT);
1042
1043 /**
1044 * @tc.steps: step7. check value level_0_nest_0 not json_object
1045 * @tc.expected: step7. E_VALUE_MISMATCH_FEILD_TYPE
1046 */
1047 CheckValueLackField(schema, VALUE_LEVEL_0_NEST_0_NOT_OBJECT, "", -E_VALUE_MISMATCH_FEILD_TYPE);
1048 }
1049
1050 /**
1051 * @tc.name: Value LackField 002
1052 * @tc.desc: check the value which lack field
1053 * @tc.type: FUNC
1054 * @tc.require: AR000DR9K5
1055 * @tc.author: xiaozhenjian
1056 */
1057 HWTEST_F(DistributedDBSchemaObjectTest, ValueLackField002, TestSize.Level1)
1058 {
1059 SchemaObject schema;
1060 int errCode = schema.ParseFromSchemaString(SCHEMA_FOR_TEST_NOTNULL_AND_DEFAULT);
1061 EXPECT_EQ(errCode, E_OK);
1062
1063 /**
1064 * @tc.steps: step1. check value lack entire level_1_nest_0
1065 * @tc.expected: step1. E_VALUE_MATCH_AMENDED
1066 */
1067 ValueObject val;
1068 CheckValueLackField(schema, VALUE_LACK_LEVEL_1_NEST_0, "", -E_VALUE_MATCH_AMENDED, val);
1069 // Check Field Existence or not
1070 EXPECT_EQ(val.IsFieldPathExist(FieldPath{"level_0_nest_0", "level_1_nest_0"}), true);
1071 EXPECT_EQ(val.IsFieldPathExist(FieldPath{"level_0_nest_0", "level_1_nest_0", "no_notnull_has_default"}), true);
1072 EXPECT_EQ(val.IsFieldPathExist(FieldPath{"level_0_nest_0", "level_1_nest_0", "has_notnull_has_default"}), true);
1073 EXPECT_EQ(val.IsFieldPathExist(FieldPath{"level_0_nest_0", "level_1_nest_0", "level_2_nest_0"}), true);
1074 EXPECT_EQ(val.IsFieldPathExist(FieldPath{"level_0_nest_0", "level_1_nest_0", "level_2_nest_0", "extra_0"}), true);
1075 EXPECT_EQ(val.IsFieldPathExist(FieldPath{"level_0_nest_0", "level_1_nest_0", "level_2_nest_0", "extra_1"}), false);
1076 EXPECT_EQ(val.IsFieldPathExist(FieldPath{"level_0_nest_0", "level_1_nest_0", "level_2_nest_0", "extra_2"}), false);
1077 EXPECT_EQ(val.IsFieldPathExist(FieldPath{"level_0_nest_0", "level_1_nest_0", "level_2_nest_1"}), false);
1078 // Check Field value
1079 FieldValue theValue;
1080 EXPECT_EQ(val.GetFieldValueByFieldPath(FieldPath{"level_0_nest_0", "level_1_nest_0", "no_notnull_has_default"},
1081 theValue), E_OK);
1082 EXPECT_EQ(theValue.integerValue, 100);
1083 EXPECT_EQ(val.GetFieldValueByFieldPath(FieldPath{"level_0_nest_0", "level_1_nest_0", "has_notnull_has_default"},
1084 theValue), E_OK);
1085 EXPECT_LT(std::abs(theValue.doubleValue - 3.14), 0.1);
1086 EXPECT_EQ(val.GetFieldValueByFieldPath(FieldPath{"level_0_nest_0", "level_1_nest_0", "level_2_nest_0", "extra_0"},
1087 theValue), E_OK);
1088 EXPECT_EQ(theValue.stringValue == std::string("3.1415"), true);
1089 }
1090
1091 /**
1092 * @tc.name: SchemaObjectErrTest
1093 * @tc.desc: Parse Schema Object err scene
1094 * @tc.type: FUNC
1095 * @tc.require: DTS2024073106613
1096 * @tc.author: suyue
1097 */
1098 HWTEST_F(DistributedDBSchemaObjectTest, SchemaObjectErrTest001, TestSize.Level1)
1099 {
1100 /**
1101 * @tc.steps: step1. Call GetExtractFuncName interface with NONE SchemaType.
1102 * @tc.expected: step1. Get non-JSON string.
1103 */
1104 SchemaObject schema;
1105 std::string str1 = schema.GetExtractFuncName(SchemaType::NONE);
1106 const std::string expectStr1 = "flatbuffer_extract_by_path";
1107 EXPECT_TRUE(str1.compare(0, expectStr1.length(), expectStr1) == 0);
1108
1109 /**
1110 * @tc.steps: step2. Call interfaces with empty FieldPath.
1111 * @tc.expected: step2. return -E_INVALID_ARGS.
1112 */
1113 FieldPath inFieldpath1 = {};
1114 std::string str2 = schema.GenerateExtractSQL(SchemaType::JSON, inFieldpath1, FieldType::LEAF_FIELD_BOOL, 0, "");
1115 const std::string expectStr2 = "";
1116 EXPECT_TRUE(str2.compare(0, expectStr2.length(), "") == 0);
1117 FieldType schemaFieldType = FieldType::LEAF_FIELD_BOOL;
1118 int ret = schema.CheckQueryableAndGetFieldType(inFieldpath1, schemaFieldType);
1119 EXPECT_EQ(ret, -E_INVALID_ARGS);
1120
1121 /**
1122 * @tc.steps: step3. Call interfaces with LEAF_FIELD_NULL FieldType.
1123 * @tc.expected: step3. return -E_NOT_FOUND.
1124 */
1125 FieldPath inFieldpath2 = {"test"};
1126 str2 = schema.GenerateExtractSQL(SchemaType::JSON, inFieldpath2, FieldType::LEAF_FIELD_NULL, 0, "");
1127 EXPECT_TRUE(str2.compare(0, expectStr2.length(), "") == 0);
1128 ret = schema.CheckQueryableAndGetFieldType(inFieldpath2, schemaFieldType);
1129 EXPECT_EQ(ret, -E_NOT_FOUND);
1130 }
1131
1132 /**
1133 * @tc.name: SchemaObjectErrTest002
1134 * @tc.desc: Parse Schema Object err scene
1135 * @tc.type: FUNC
1136 * @tc.require: DTS2024073106613
1137 * @tc.author: suyue
1138 */
1139 HWTEST_F(DistributedDBSchemaObjectTest, SchemaObjectErrTest002, TestSize.Level1)
1140 {
1141 /**
1142 * @tc.steps: step1. Call interfaces without Schema Parse.
1143 * @tc.expected: step1. return -E_NOT_PERMIT.
1144 */
1145 SchemaObject schema;
1146 IndexDifference indexDiffer;
1147 int ret = schema.CompareAgainstSchemaObject(schema, indexDiffer);
1148 EXPECT_EQ(ret, -E_NOT_PERMIT);
1149 ValueObject inValue;
1150 ret = schema.CheckValueAndAmendIfNeed(ValueSource::FROM_LOCAL, inValue);
1151 EXPECT_EQ(ret, -E_NOT_PERMIT);
1152
1153 const Value val = {0};
1154 ret = schema.VerifyValue(ValueSource::FROM_LOCAL, val);
1155 EXPECT_EQ(ret, -E_NOT_PERMIT);
1156
1157 /**
1158 * @tc.steps: step2. Call VerifyValue interface when RawValue first para is nullptr.
1159 * @tc.expected: step2. return -E_INVALID_ARGS.
1160 */
1161 ret = schema.VerifyValue(ValueSource::FROM_LOCAL, RawValue{nullptr, 0});
1162 EXPECT_EQ(ret, -E_INVALID_ARGS);
1163
1164 /**
1165 * @tc.steps: step3. Parse twice same schema.
1166 * @tc.expected: step3. second return -E_NOT_PERMIT.
1167 */
1168 SchemaObject schema1;
1169 int stepOne = schema1.ParseFromSchemaString(VALID_SCHEMA_FULL_DEFINE);
1170 EXPECT_EQ(stepOne, E_OK);
1171 stepOne = schema1.ParseFromSchemaString(VALID_SCHEMA_FULL_DEFINE);
1172 EXPECT_EQ(stepOne, -E_NOT_PERMIT);
1173 }
1174 #endif