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
16 #include <cstddef>
17 #include <cstdlib>
18 #include <cstring>
19 #include <gtest/gtest.h>
20 #include <securec.h>
21
22 #include "bus_center_info_key.h"
23 #include "bus_center_manager.h"
24 #include "lnn_data_cloud_sync.h"
25 #include "lnn_device_info_recovery.h"
26 #include "lnn_log.h"
27 #include "lnn_node_info.h"
28 #include "lnn_parameter_utils.h"
29 #include "softbus_adapter_mem.h"
30 #include "softbus_common.h"
31 #include "softbus_error_code.h"
32
33 namespace OHOS {
34 using namespace testing::ext;
35 using namespace testing;
36
37 constexpr char VALUE[] = "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000#1";
38 constexpr char RIGHT_KEY[] = "123456789#1111111111111111111111111111111111111111111111111111111111111111#DEVICE_NAME";
39
40 class LNNDataCloudSyncTest : public testing::Test {
41 public:
42 static void SetUpTestCase();
43 static void TearDownTestCase();
44 void SetUp();
45 void TearDown();
46 };
47
SetUpTestCase()48 void LNNDataCloudSyncTest::SetUpTestCase() { }
49
TearDownTestCase()50 void LNNDataCloudSyncTest::TearDownTestCase() { }
51
SetUp()52 void LNNDataCloudSyncTest::SetUp()
53 {
54 LNN_LOGI(LNN_TEST, "LNNDataCloudSyncTest start");
55 }
56
TearDown()57 void LNNDataCloudSyncTest::TearDown() { }
58
59 /*
60 * @tc.name: LnnAsyncCallLedgerAllDataSyncToDB_Test_001
61 * @tc.desc: LnnAsyncCallLedgerAllDataSyncToDB
62 * @tc.type: FUNC
63 * @tc.require:
64 */
65 HWTEST_F(LNNDataCloudSyncTest, LnnAsyncCallLedgerAllDataSyncToDB_Test_001, TestSize.Level1)
66 {
67 NodeInfo *info = nullptr;
68 int32_t ret = LnnAsyncCallLedgerAllDataSyncToDB(info);
69 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
70 info = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
71 ASSERT_NE(info, nullptr);
72 info->accountId = 0;
73 ret = LnnLedgerAllDataSyncToDB(info, false, nullptr);
74 if (ret != SOFTBUS_NOT_IMPLEMENT) {
75 EXPECT_EQ(ret, SOFTBUS_KV_CLOUD_DISABLED);
76 } else {
77 EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
78 }
79 info->accountId = 18390933952;
80 ret = LnnAsyncCallLedgerAllDataSyncToDB(info);
81 EXPECT_NE(ret, SOFTBUS_OK);
82 SoftBusFree(info);
83 }
84
85 /*
86 * @tc.name: LnnLedgerDataChangeSyncToDB_Test_002
87 * @tc.desc: LnnLedgerDataChangeSyncToDB
88 * @tc.type: FUNC
89 * @tc.require:
90 */
91 HWTEST_F(LNNDataCloudSyncTest, LnnLedgerDataChangeSyncToDB_Test_002, TestSize.Level1)
92 {
93 char *key = nullptr;
94 int32_t ret = LnnLedgerDataChangeSyncToDB(key, VALUE, strlen(VALUE));
95 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
96 LnnDeleteSyncToDB();
97 }
98
99 /*
100 * @tc.name: LnnDBDataChangeSyncToCache_Test_003
101 * @tc.desc: LnnDBDataChangeSyncToCache
102 * @tc.type: FUNC
103 * @tc.require:
104 */
105 HWTEST_F(LNNDataCloudSyncTest, LnnDBDataChangeSyncToCache_Test_003, TestSize.Level1)
106 {
107 char *key = nullptr;
108 char *value = nullptr;
109 ChangeType type = DB_UPDATE;
110 int32_t ret = LnnDBDataChangeSyncToCache(key, value, type);
111 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
112 ret = LnnDBDataChangeSyncToCache(RIGHT_KEY, value, type);
113 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
114 ret = LnnDBDataChangeSyncToCache(RIGHT_KEY, VALUE, type);
115 NodeInfo localCaheInfo;
116 if (LnnGetLocalCacheNodeInfo(&localCaheInfo) == SOFTBUS_NOT_IMPLEMENT) {
117 EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
118 } else {
119 EXPECT_EQ(ret, SOFTBUS_OK);
120 }
121 type = DB_DELETE;
122 ret = LnnDBDataChangeSyncToCache(RIGHT_KEY, VALUE, type);
123 EXPECT_EQ(ret, SOFTBUS_OK);
124 type = DB_CHANGE_TYPE_MAX;
125 ret = LnnDBDataChangeSyncToCache(RIGHT_KEY, VALUE, type);
126 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
127 }
128
129 /*
130 * @tc.name: LnnDBDataAddChangeSyncToCache_Test_004
131 * @tc.desc: LnnDBDataAddChangeSyncToCache
132 * @tc.type: FUNC
133 * @tc.require:
134 */
135 HWTEST_F(LNNDataCloudSyncTest, LnnDBDataAddChangeSyncToCache_Test_004, TestSize.Level1)
136 {
137 const char **key = nullptr;
138 const char **value = nullptr;
139 int32_t keySize = 0;
140 int32_t ret = LnnDBDataAddChangeSyncToCache(key, value, keySize);
141 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
142 }
143 } // namespace OHOS
144