1 /*
2 * Copyright (c) 2023 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 "cloud/schema_mgr.h"
16
17 #include <gtest/gtest.h>
18
19 #include "db_errno.h"
20 #include "distributeddb_tools_unit_test.h"
21 #include "relational_store_manager.h"
22 #include "relational_schema_object.h"
23 #include "distributeddb_data_generate_unit_test.h"
24 #include "relational_sync_able_storage.h"
25 #include "relational_store_instance.h"
26 #include "sqlite_relational_store.h"
27 #include "log_table_manager_factory.h"
28
29 using namespace testing::ext;
30 using namespace DistributedDB;
31 using namespace DistributedDBUnitTest;
32 using namespace std;
33
34 namespace {
35 constexpr auto TABLE_NAME_1 = "tableName1";
36 constexpr auto TABLE_NAME_2 = "tableName2";
37 constexpr auto TABLE_NAME_3 = "tableName3";
38 constexpr auto TABLE_NAME_4 = "tableName4";
39
40 constexpr auto FIELD_NAME_1 = "field_name_1";
41 constexpr auto FIELD_NAME_2 = "field_name_2";
42 constexpr auto FIELD_NAME_3 = "field_name_3";
43 constexpr auto FIELD_NAME_4 = "FIELD_name_4";
44
45 std::unique_ptr<SchemaMgr> g_schemaMgr = nullptr;
46
47 class DistributedDBCloudSchemaMgrTest : public testing::Test {
48 public:
49 static void SetUpTestCase(void);
50 static void TearDownTestCase(void);
51 void SetUp();
52 void TearDown();
53 };
54
SetUpTestCase(void)55 void DistributedDBCloudSchemaMgrTest::SetUpTestCase(void)
56 {
57 }
58
TearDownTestCase(void)59 void DistributedDBCloudSchemaMgrTest::TearDownTestCase(void)
60 {
61 }
62
SetUp(void)63 void DistributedDBCloudSchemaMgrTest::SetUp(void)
64 {
65 g_schemaMgr = std::make_unique<SchemaMgr>();
66 }
67
TearDown(void)68 void DistributedDBCloudSchemaMgrTest::TearDown(void)
69 {
70 g_schemaMgr = nullptr;
71 }
72
73 DataBaseSchema g_schema = {
74 .tables = {
75 {
76 .name = TABLE_NAME_1,
77 .sharedTableName = "",
78 .fields = {
79 {
80 .colName = FIELD_NAME_1,
81 .type = TYPE_INDEX<int64_t>,
82 .primary = true,
83 .nullable = true,
84 },
85 {
86 .colName = FIELD_NAME_2,
87 .type = TYPE_INDEX<int64_t>,
88 .primary = false,
89 .nullable = true,
90 }
91 }
92 },
93 {
94 .name = TABLE_NAME_2,
95 .sharedTableName = "",
96 .fields = {
97 {
98 .colName = FIELD_NAME_1,
99 .type = TYPE_INDEX<int64_t>,
100 .primary = true,
101 .nullable = true,
102 },
103 {
104 .colName = FIELD_NAME_2,
105 .type = TYPE_INDEX<int64_t>,
106 .primary = false,
107 .nullable = true,
108 }
109 }
110 },
111 {
112 .name = TABLE_NAME_3,
113 .sharedTableName = "",
114 .fields = {
115 {
116 .colName = FIELD_NAME_1,
117 .type = TYPE_INDEX<Asset>,
118 .primary = true,
119 .nullable = true,
120 },
121 {
122 .colName = FIELD_NAME_2,
123 .type = TYPE_INDEX<std::string>,
124 .primary = false,
125 .nullable = true,
126 },
127 {
128 .colName = FIELD_NAME_3,
129 .type = TYPE_INDEX<int64_t>,
130 .primary = false,
131 .nullable = true,
132 }
133 }
134 },
135 {
136 .name = TABLE_NAME_4,
137 .sharedTableName = "",
138 .fields = {
139 {
140 .colName = FIELD_NAME_1,
141 .type = TYPE_INDEX<Assets>,
142 .primary = false,
143 .nullable = true,
144 },
145 {
146 .colName = FIELD_NAME_2,
147 .type = TYPE_INDEX<std::string>,
148 .primary = false,
149 .nullable = true,
150 },
151 {
152 .colName = FIELD_NAME_3,
153 .type = TYPE_INDEX<int64_t>,
154 .primary = false,
155 .nullable = true,
156 }
157 }
158 }
159 }
160 };
161
162 DataBaseSchema g_schema2 = {
163 .tables = {
164 {
165 .name = TABLE_NAME_2,
166 .sharedTableName = "",
167 .fields = {
168 {
169 .colName = FIELD_NAME_1,
170 .type = TYPE_INDEX<int64_t>,
171 .primary = true,
172 .nullable = true,
173 },
174 {
175 .colName = FIELD_NAME_2,
176 .type = TYPE_INDEX<int64_t>,
177 .primary = false,
178 .nullable = true,
179 }
180 }
181 },
182 {
183 .name = TABLE_NAME_3,
184 .sharedTableName = "",
185 .fields = {
186 {
187 .colName = FIELD_NAME_1,
188 .type = TYPE_INDEX<int64_t>,
189 .primary = true,
190 .nullable = true,
191 },
192 {
193 .colName = FIELD_NAME_2,
194 .type = TYPE_INDEX<int64_t>,
195 .primary = false,
196 .nullable = true,
197 }
198 }
199 },
200 {
201 .name = TABLE_NAME_4,
202 .sharedTableName = "",
203 .fields = {
204 {
205 .colName = FIELD_NAME_1,
206 .type = TYPE_INDEX<int64_t>,
207 .primary = true,
208 .nullable = true,
209 },
210 {
211 .colName = FIELD_NAME_2,
212 .type = TYPE_INDEX<int64_t>,
213 .primary = false,
214 .nullable = true,
215 }
216 }
217 }
218 }
219 };
220
221 DataBaseSchema g_schema3 = {
222 .tables = {
223 {
224 .name = TABLE_NAME_1,
225 .sharedTableName = "",
226 .fields = {
227 {
228 .colName = FIELD_NAME_1,
229 .type = TYPE_INDEX<int64_t>,
230 .primary = true,
231 .nullable = true,
232 },
233 {
234 .colName = FIELD_NAME_4,
235 .type = TYPE_INDEX<int64_t>,
236 .primary = false,
237 .nullable = true,
238 }
239 }
240 },
241 {
242 .name = TABLE_NAME_2,
243 .sharedTableName = "",
244 .fields = {
245 {
246 .colName = FIELD_NAME_4,
247 .type = TYPE_INDEX<int64_t>,
248 .primary = true,
249 .nullable = true,
250 }
251 }
252 }
253 }
254 };
255
SetField(std::string fieldName,std::string dataType,bool nullable)256 FieldInfo SetField(std::string fieldName, std::string dataType, bool nullable)
257 {
258 FieldInfo field;
259 field.SetFieldName(fieldName);
260 field.SetDataType(dataType);
261 field.SetNotNull(!nullable);
262 return field;
263 }
264
265 /**
266 * @tc.name: SchemaMgrTest001
267 * @tc.desc: Cloud schema and local schema are not been set
268 * test situation: TABLE_NAME exist and not exist(TABLE_NAME_3)
269 * @tc.type: FUNC
270 * @tc.require:
271 * @tc.author: wanyi
272 */
273 HWTEST_F(DistributedDBCloudSchemaMgrTest, SchemaMgrTest001, TestSize.Level0)
274 {
275 FieldInfo field1 = SetField(FIELD_NAME_1, "int", true);
276 FieldInfo field2 = SetField(FIELD_NAME_2, "int", true);
277 TableInfo table;
278 table.SetTableName(TABLE_NAME_2);
279 table.AddField(field1);
280 table.AddField(field2);
281 table.SetPrimaryKey(FIELD_NAME_1, 1);
282 table.SetTableSyncType(TableSyncType::CLOUD_COOPERATION);
283 RelationalSchemaObject localSchema;
284 localSchema.AddRelationalTable(table);
285
286 EXPECT_EQ(g_schemaMgr->ChkSchema(TABLE_NAME_1, localSchema), -E_SCHEMA_MISMATCH);
287 EXPECT_EQ(g_schemaMgr->ChkSchema(TABLE_NAME_2, localSchema), -E_SCHEMA_MISMATCH);
288 EXPECT_EQ(g_schemaMgr->ChkSchema(TABLE_NAME_3, localSchema), -E_SCHEMA_MISMATCH);
289 }
290
291 /**
292 * @tc.name: SchemaMgrTest002
293 * @tc.desc: Cloud schema and local schema are the same
294 * @tc.type: FUNC
295 * @tc.require:
296 * @tc.author: wanyi
297 */
298 HWTEST_F(DistributedDBCloudSchemaMgrTest, SchemaMgrTest002, TestSize.Level0)
299 {
300 FieldInfo field1 = SetField(FIELD_NAME_1, "int", true);
301 FieldInfo field2 = SetField(FIELD_NAME_2, "int", true);
302 TableInfo table;
303 table.SetTableName(TABLE_NAME_2);
304 table.AddField(field1);
305 table.AddField(field2);
306 table.SetPrimaryKey(FIELD_NAME_1, 1);
307 table.SetTableSyncType(TableSyncType::CLOUD_COOPERATION);
308 RelationalSchemaObject localSchema;
309 localSchema.AddRelationalTable(table);
310
311 g_schemaMgr->SetCloudDbSchema(g_schema);
312 EXPECT_EQ(g_schemaMgr->ChkSchema(TABLE_NAME_2, localSchema), E_OK);
313 EXPECT_EQ(g_schemaMgr->ChkSchema(TABLE_NAME_2, localSchema), E_OK);
314 EXPECT_EQ(g_schemaMgr->ChkSchema(TABLE_NAME_2, localSchema), E_OK);
315 }
316
317 /**
318 * @tc.name: SchemaMgrTest003
319 * @tc.desc: Local schema contain extra primary key
320 * @tc.type: FUNC
321 * @tc.require:
322 * @tc.author: wanyi
323 */
324 HWTEST_F(DistributedDBCloudSchemaMgrTest, SchemaMgrTest003, TestSize.Level0)
325 {
326 FieldInfo field1 = SetField(FIELD_NAME_1, "int", true);
327 FieldInfo field2 = SetField(FIELD_NAME_2, "int", true);
328 FieldInfo field3 = SetField(FIELD_NAME_3, "int", true);
329
330 TableInfo table;
331 table.SetTableName(TABLE_NAME_2);
332 table.AddField(field1);
333 table.AddField(field2);
334 table.AddField(field3);
335 table.SetPrimaryKey(FIELD_NAME_1, 1);
336 table.SetPrimaryKey(FIELD_NAME_3, 2);
337 table.SetTableSyncType(TableSyncType::CLOUD_COOPERATION);
338 RelationalSchemaObject localSchema;
339 localSchema.AddRelationalTable(table);
340
341 g_schemaMgr->SetCloudDbSchema(g_schema);
342 EXPECT_EQ(g_schemaMgr->ChkSchema(TABLE_NAME_2, localSchema), -E_SCHEMA_MISMATCH);
343 }
344
345 /**
346 * @tc.name: SchemaMgrTest003
347 * @tc.desc: Column from local schema is not within cloud schema but is not nullable
348 * @tc.type: FUNC
349 * @tc.require:
350 * @tc.author: wanyi
351 */
352 HWTEST_F(DistributedDBCloudSchemaMgrTest, SchemaMgrTest004, TestSize.Level0)
353 {
354 FieldInfo field1 = SetField(FIELD_NAME_1, "int", true);
355 FieldInfo field2 = SetField(FIELD_NAME_2, "int", true);
356 FieldInfo field3 = SetField(FIELD_NAME_2, "int", false);
357
358 TableInfo table;
359 table.SetTableName(TABLE_NAME_2);
360 table.AddField(field1);
361 table.AddField(field2);
362 table.AddField(field3);
363 table.SetPrimaryKey(FIELD_NAME_1, 1);
364 table.SetTableSyncType(TableSyncType::CLOUD_COOPERATION);
365 RelationalSchemaObject localSchema;
366 localSchema.AddRelationalTable(table);
367
368 g_schemaMgr->SetCloudDbSchema(g_schema);
369 EXPECT_EQ(g_schemaMgr->ChkSchema(TABLE_NAME_2, localSchema), -E_SCHEMA_MISMATCH);
370 }
371
372 /**
373 * @tc.name: SchemaMgrTest003
374 * @tc.desc: Local schema contain extra noraml key with default value but cannot be null
375 * @tc.type: FUNC
376 * @tc.require:
377 * @tc.author: wanyi
378 */
379 HWTEST_F(DistributedDBCloudSchemaMgrTest, SchemaMgrTest005, TestSize.Level0)
380 {
381 FieldInfo field1 = SetField(FIELD_NAME_1, "int", true);
382 FieldInfo field2 = SetField(FIELD_NAME_2, "int", true);
383 FieldInfo field3 = SetField(FIELD_NAME_3, "int", false);
384 field3.SetDefaultValue("0");
385
386 TableInfo table;
387 table.SetTableName(TABLE_NAME_2);
388 table.AddField(field1);
389 table.AddField(field2);
390 table.AddField(field3);
391 table.SetPrimaryKey(FIELD_NAME_1, 1);
392 table.SetTableSyncType(TableSyncType::CLOUD_COOPERATION);
393 RelationalSchemaObject localSchema;
394 localSchema.AddRelationalTable(table);
395
396 g_schemaMgr->SetCloudDbSchema(g_schema);
397 EXPECT_EQ(g_schemaMgr->ChkSchema(TABLE_NAME_2, localSchema), E_OK);
398 }
399
400 /**
401 * @tc.name: SchemaMgrTest003
402 * @tc.desc: Local schema contain extra noraml key with default value but cannot be null
403 * @tc.type: FUNC
404 * @tc.require:
405 * @tc.author: wanyi
406 */
407 HWTEST_F(DistributedDBCloudSchemaMgrTest, SchemaMgrTest006, TestSize.Level0)
408 {
409 FieldInfo field1 = SetField(FIELD_NAME_1, "int", true);
410 FieldInfo field2 = SetField(FIELD_NAME_2, "int", true);
411 FieldInfo field3 = SetField(FIELD_NAME_3, "int", true);
412 field3.SetDefaultValue("0");
413
414 TableInfo table;
415 table.SetTableName(TABLE_NAME_2);
416 table.AddField(field1);
417 table.AddField(field2);
418 table.AddField(field3);
419 table.SetPrimaryKey(FIELD_NAME_1, 1);
420 table.SetTableSyncType(TableSyncType::CLOUD_COOPERATION);
421 RelationalSchemaObject localSchema;
422 localSchema.AddRelationalTable(table);
423
424 g_schemaMgr->SetCloudDbSchema(g_schema);
425 EXPECT_EQ(g_schemaMgr->ChkSchema(TABLE_NAME_2, localSchema), E_OK);
426 }
427
428 /**
429 * @tc.name: SchemaMgrTest003
430 * @tc.desc: Local schema contain extra noraml key with default value but cannot be null
431 * @tc.type: FUNC
432 * @tc.require:
433 * @tc.author: wanyi
434 */
435 HWTEST_F(DistributedDBCloudSchemaMgrTest, SchemaMgrTest007, TestSize.Level0)
436 {
437 FieldInfo field1 = SetField(FIELD_NAME_1, "int", true);
438 FieldInfo field2 = SetField(FIELD_NAME_2, "int", true);
439 FieldInfo field3 = SetField(FIELD_NAME_3, "int", true);
440
441 TableInfo table;
442 table.SetTableName(TABLE_NAME_2);
443 table.AddField(field1);
444 table.AddField(field2);
445 table.AddField(field3);
446 table.SetPrimaryKey(FIELD_NAME_1, 1);
447 table.SetTableSyncType(TableSyncType::CLOUD_COOPERATION);
448 RelationalSchemaObject localSchema;
449 localSchema.AddRelationalTable(table);
450
451 g_schemaMgr->SetCloudDbSchema(g_schema);
452 EXPECT_EQ(g_schemaMgr->ChkSchema(TABLE_NAME_2, localSchema), E_OK);
453 }
454
455 /**
456 * @tc.name: SchemaMgrTest008
457 * @tc.desc: Cloud schema or local schema are not exist
458 * @tc.type: FUNC
459 * @tc.require:
460 * @tc.author: wanyi
461 */
462 HWTEST_F(DistributedDBCloudSchemaMgrTest, SchemaMgrTest008, TestSize.Level0)
463 {
464 FieldInfo field1 = SetField(FIELD_NAME_1, "int", true);
465 FieldInfo field2 = SetField(FIELD_NAME_2, "int", true);
466 TableInfo table;
467 table.SetTableName(TABLE_NAME_3);
468 table.AddField(field1);
469 table.AddField(field2);
470 table.SetPrimaryKey(FIELD_NAME_1, 1);
471 table.SetTableSyncType(TableSyncType::CLOUD_COOPERATION);
472
473 TableInfo table2;
474 table2.SetTableName(TABLE_NAME_1);
475 table2.AddField(field1);
476 table2.AddField(field2);
477 table2.SetPrimaryKey(FIELD_NAME_1, 1);
478 table2.SetTableSyncType(TableSyncType::CLOUD_COOPERATION);
479
480 RelationalSchemaObject localSchema;
481 localSchema.AddRelationalTable(table);
482 localSchema.AddRelationalTable(table2);
483
484 g_schemaMgr->SetCloudDbSchema(g_schema);
485 // local schema exist but cloud schema not exist
486 EXPECT_EQ(g_schemaMgr->ChkSchema(TABLE_NAME_3, localSchema), -E_SCHEMA_MISMATCH);
487 // cloud schema exist but local schema not exist
488 EXPECT_EQ(g_schemaMgr->ChkSchema(TABLE_NAME_2, localSchema), -E_SCHEMA_MISMATCH);
489 // Both cloud schema and local schema does not exist
490 EXPECT_EQ(g_schemaMgr->ChkSchema(TABLE_NAME_4, localSchema), -E_SCHEMA_MISMATCH);
491 // Both cloud schema and local schema exist
492 EXPECT_EQ(g_schemaMgr->ChkSchema(TABLE_NAME_1, localSchema), E_OK);
493
494 g_schemaMgr->SetCloudDbSchema(g_schema2);
495 EXPECT_EQ(g_schemaMgr->ChkSchema(TABLE_NAME_3, localSchema), E_OK);
496 EXPECT_EQ(g_schemaMgr->ChkSchema(TABLE_NAME_1, localSchema), -E_SCHEMA_MISMATCH);
497 }
498
499 /**
500 * @tc.name: SchemaMgrTest008
501 * @tc.desc: Test schema mgr with empty local schema
502 * @tc.type: FUNC
503 * @tc.require:
504 * @tc.author: wanyi
505 */
506 HWTEST_F(DistributedDBCloudSchemaMgrTest, SchemaMgrTest009, TestSize.Level0)
507 {
508 RelationalSchemaObject localSchema;
509 g_schemaMgr->SetCloudDbSchema(g_schema);
510 EXPECT_EQ(g_schemaMgr->ChkSchema(TABLE_NAME_1, localSchema), -E_SCHEMA_MISMATCH);
511 }
512
513 /**
514 * @tc.name: SchemaMgrTest010
515 * @tc.desc: Test local schema with un-expected sync type
516 * @tc.type: FUNC
517 * @tc.require:
518 * @tc.author: wanyi
519 */
520 HWTEST_F(DistributedDBCloudSchemaMgrTest, SchemaMgrTest010, TestSize.Level0)
521 {
522 FieldInfo field1 = SetField(FIELD_NAME_1, "int", true);
523 FieldInfo field2 = SetField(FIELD_NAME_2, "int", true);
524 FieldInfo field3 = SetField(FIELD_NAME_3, "int", true);
525
526 TableInfo table;
527 table.SetTableName(TABLE_NAME_2);
528 table.AddField(field1);
529 table.AddField(field2);
530 table.AddField(field3);
531 table.SetPrimaryKey(FIELD_NAME_1, 1);
532 table.SetTableSyncType(TableSyncType::DEVICE_COOPERATION);
533 RelationalSchemaObject localSchema;
534 localSchema.AddRelationalTable(table);
535
536 g_schemaMgr->SetCloudDbSchema(g_schema);
537 EXPECT_EQ(g_schemaMgr->ChkSchema(TABLE_NAME_2, localSchema), -E_NOT_SUPPORT);
538 }
539
540 /**
541 * @tc.name: SchemaMgrTest011
542 * @tc.desc: Test local schema with un-expected data type
543 * @tc.type: FUNC
544 * @tc.require:
545 * @tc.author: wanyi
546 */
547 HWTEST_F(DistributedDBCloudSchemaMgrTest, SchemaMgrTest011, TestSize.Level0)
548 {
549 FieldInfo field1 = SetField(FIELD_NAME_1, "int", true);
550 FieldInfo field2 = SetField(FIELD_NAME_2, "text", true);
551 FieldInfo field3 = SetField(FIELD_NAME_3, "int", true);
552
553 TableInfo table;
554 table.SetTableName(TABLE_NAME_2);
555 table.AddField(field1);
556 table.AddField(field2);
557 table.AddField(field3);
558 table.SetPrimaryKey(FIELD_NAME_1, 1);
559 table.SetTableSyncType(TableSyncType::CLOUD_COOPERATION);
560 RelationalSchemaObject localSchema;
561 localSchema.AddRelationalTable(table);
562
563 g_schemaMgr->SetCloudDbSchema(g_schema);
564 EXPECT_EQ(g_schemaMgr->ChkSchema(TABLE_NAME_2, localSchema), -E_SCHEMA_MISMATCH);
565 }
566
567 /**
568 * @tc.name: SchemaMgrTest012
569 * @tc.desc: table 3 contain primary asset field
570 * @tc.type: FUNC
571 * @tc.require:
572 * @tc.author: wanyi
573 */
574 HWTEST_F(DistributedDBCloudSchemaMgrTest, SchemaMgrTest012, TestSize.Level0)
575 {
576 FieldInfo field1 = SetField(FIELD_NAME_1, "blob", true);
577 FieldInfo field2 = SetField(FIELD_NAME_2, "text", true);
578 FieldInfo field3 = SetField(FIELD_NAME_3, "int", true);
579
580 TableInfo table;
581 table.SetTableName(TABLE_NAME_3);
582 table.AddField(field1);
583 table.AddField(field2);
584 table.AddField(field3);
585 table.SetPrimaryKey(FIELD_NAME_1, 1);
586 table.SetTableSyncType(TableSyncType::CLOUD_COOPERATION);
587 RelationalSchemaObject localSchema;
588 localSchema.AddRelationalTable(table);
589
590 g_schemaMgr->SetCloudDbSchema(g_schema);
591 EXPECT_EQ(g_schemaMgr->ChkSchema(TABLE_NAME_3, localSchema), -E_SCHEMA_MISMATCH);
592 }
593
594 /**
595 * @tc.name: SchemaMgrTest013
596 * @tc.desc: table 4 do not contain primary assets field
597 * @tc.type: FUNC
598 * @tc.require:
599 * @tc.author: wanyi
600 */
601 HWTEST_F(DistributedDBCloudSchemaMgrTest, SchemaMgrTest013, TestSize.Level0)
602 {
603 /**
604 * @tc.steps:step1. local schema's asset field is not primary
605 * @tc.expected: step1. return ok.
606 */
607 FieldInfo field1 = SetField(FIELD_NAME_1, "blob", true);
608 FieldInfo field2 = SetField(FIELD_NAME_2, "text", true);
609 FieldInfo field3 = SetField(FIELD_NAME_3, "int", true);
610
611 TableInfo table;
612 table.SetTableName(TABLE_NAME_4);
613 table.AddField(field1);
614 table.AddField(field2);
615 table.AddField(field3);
616 table.SetTableSyncType(TableSyncType::CLOUD_COOPERATION);
617 RelationalSchemaObject localSchema;
618 localSchema.AddRelationalTable(table);
619
620 g_schemaMgr->SetCloudDbSchema(g_schema);
621 EXPECT_EQ(g_schemaMgr->ChkSchema(TABLE_NAME_4, localSchema), E_OK);
622 /**
623 * @tc.steps:step2. local schema's asset field is primary
624 * @tc.expected: step2. return E_SCHEMA_MISMATCH.
625 */
626 table.SetPrimaryKey(FIELD_NAME_1, 1);
627 RelationalSchemaObject localSchemaWithAssetPrimary;
628 localSchemaWithAssetPrimary.AddRelationalTable(table);
629 EXPECT_EQ(g_schemaMgr->ChkSchema(TABLE_NAME_4, localSchemaWithAssetPrimary), -E_SCHEMA_MISMATCH);
630 }
631
632 /**
633 * @tc.name: SchemaMgrTest014
634 * @tc.desc: test case insensitive when table 2 contain uppercase primary key, table 1 contain uppercase field.
635 * @tc.type: FUNC
636 * @tc.require:
637 * @tc.author: chenchaohao
638 */
639 HWTEST_F(DistributedDBCloudSchemaMgrTest, SchemaMgrTest014, TestSize.Level0)
640 {
641 /**
642 * @tc.steps:step1. set local field1 uppercase and field4 lowercase
643 * @tc.expected: step1. return ok.
644 */
645 FieldInfo field1 = SetField("FIELD_name_1", "int", true);
646 FieldInfo field4 = SetField("field_name_4", "int", true);
647
648 TableInfo table1;
649 table1.SetTableName(TABLE_NAME_1);
650 table1.AddField(field1);
651 table1.AddField(field4);
652 table1.SetPrimaryKey(FIELD_NAME_1, 1);
653 table1.SetTableSyncType(TableSyncType::CLOUD_COOPERATION);
654
655 TableInfo table2;
656 table2.SetTableName(TABLE_NAME_2);
657 table2.AddField(field4);
658 table2.SetPrimaryKey(FIELD_NAME_4, 1);
659 table2.SetTableSyncType(TableSyncType::CLOUD_COOPERATION);
660
661 RelationalSchemaObject localSchema;
662 localSchema.AddRelationalTable(table1);
663 localSchema.AddRelationalTable(table2);
664
665 /**
666 * @tc.steps:step2. cloud schema's field1 is lowercase, field4 is uppercase
667 * @tc.expected: step2. return ok.
668 */
669 g_schemaMgr->SetCloudDbSchema(g_schema3);
670 EXPECT_EQ(g_schemaMgr->ChkSchema(TABLE_NAME_1, localSchema), E_OK);
671 EXPECT_EQ(g_schemaMgr->ChkSchema(TABLE_NAME_2, localSchema), E_OK);
672 }
673
674 /**
675 * @tc.name: SchemaMgrTest0015
676 * @tc.desc: Cloud schema has more fields than local schema
677 * @tc.type: FUNC
678 * @tc.require:
679 * @tc.author: chenghuitao
680 */
681 HWTEST_F(DistributedDBCloudSchemaMgrTest, SchemaMgrTest0015, TestSize.Level0)
682 {
683 FieldInfo field = SetField(FIELD_NAME_1, "int", true);
684 TableInfo table;
685 table.SetTableName(TABLE_NAME_1);
686 table.AddField(field);
687 table.SetPrimaryKey(FIELD_NAME_1, 1);
688 table.SetTableSyncType(TableSyncType::CLOUD_COOPERATION);
689 RelationalSchemaObject localSchema;
690 localSchema.AddRelationalTable(table);
691
692 g_schemaMgr->SetCloudDbSchema(g_schema);
693 EXPECT_EQ(g_schemaMgr->ChkSchema(TABLE_NAME_1, localSchema), -E_SCHEMA_MISMATCH);
694
695 g_schemaMgr->SetCloudDbSchema(g_schema, localSchema);
696 EXPECT_EQ(g_schemaMgr->ChkSchema(TABLE_NAME_1, localSchema), E_OK);
697 }
698
699 /**
700 * @tc.name: FieldInfo001
701 * @tc.desc: Test Relational field info.
702 * @tc.type: FUNC
703 * @tc.require:
704 * @tc.author: zhangqiquan
705 */
706 HWTEST_F(DistributedDBCloudSchemaMgrTest, FieldInfo001, TestSize.Level0)
707 {
708 FieldInfo fieldInfo;
709 fieldInfo.SetDataType("long");
710 EXPECT_EQ(fieldInfo.GetStorageType(), StorageType::STORAGE_TYPE_INTEGER);
711 fieldInfo.SetDataType("LONG");
712 EXPECT_EQ(fieldInfo.GetStorageType(), StorageType::STORAGE_TYPE_INTEGER);
713 }
714 }