1 /*
2 * Copyright (c) 2024 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 #define LOG_TAG "GdbFuncTest"
17 #include <gtest/gtest.h>
18
19 #include <variant>
20
21 #include "gdb_errors.h"
22 #include "connection_pool.h"
23 #include "gdb_helper.h"
24 #include "grd_adapter_manager.h"
25 #include "logger.h"
26
27 using namespace testing::ext;
28 using namespace OHOS::DistributedDataAip;
29 class GdbFuncTest : public testing::Test {
30 public:
31 static void SetUpTestCase();
32 static void TearDownTestCase();
33 void SetUp();
34 void TearDown();
35 };
36
SetUpTestCase()37 void GdbFuncTest::SetUpTestCase()
38 {
39 LOG_INFO("SetUpTestCase");
40 }
41
TearDownTestCase()42 void GdbFuncTest::TearDownTestCase()
43 {
44 LOG_INFO("TearDownTestCase");
45 }
46
SetUp()47 void GdbFuncTest::SetUp()
48 {
49 LOG_INFO("SetUp");
50 if (!IsSupportArkDataDb()) {
51 GTEST_SKIP() << "Current testcase is not compatible from current gdb";
52 }
53 }
54
TearDown()55 void GdbFuncTest::TearDown()
56 {
57 LOG_INFO("TearDown");
58 }
59
60 HWTEST_F(GdbFuncTest, GdbStore_Func_OpenClose01, TestSize.Level1)
61 {
62 int errCode = E_OK;
63 std::string dbName = "testReopendb";
64 std::string dbPath = "/data";
65 auto config = StoreConfig(dbName, dbPath);
66
67 auto store = GDBHelper::GetDBStore(config, errCode);
68 EXPECT_NE(store, nullptr);
69 EXPECT_EQ(errCode, E_OK);
70
71 auto result = store->QueryGql("");
72 EXPECT_NE(result.first, E_OK);
73
74 store->Close();
75 result = store->QueryGql("abc");
76 EXPECT_NE(result.first, E_OK);
77
78 store = GDBHelper::GetDBStore(config, errCode);
79 EXPECT_EQ(errCode, E_OK);
80
81 GDBHelper::DeleteDBStore(config);
82
83 auto store1 = GDBHelper::GetDBStore(config, errCode);
84 EXPECT_NE(store, nullptr);
85 EXPECT_EQ(errCode, E_OK);
86 result = store1->ExecuteGql(
87 "CREATE GRAPH test {(person: Person {name STRING, age INT, sex BOOL DEFAULT false})}");
88 EXPECT_EQ(result.first, E_OK);
89 GDBHelper::DeleteDBStore(config);
90 }
91
92 HWTEST_F(GdbFuncTest, GdbStore_Func_CreateConnPool01, TestSize.Level1)
93 {
94 int32_t errCode = E_OK;
95 auto config = StoreConfig("test", "/data", DBType::DB_VECTOR);
96 auto connectionPool = ConnectionPool::Create(config, errCode);
97 EXPECT_EQ(errCode, E_NOT_SUPPORT);
98 }
99
100 HWTEST_F(GdbFuncTest, GdbStore_Func_CreateConnPool02, TestSize.Level1)
101 {
102 int32_t errCode = E_OK;
103 auto config = StoreConfig("test", "/data", DBType::DB_GRAPH);
104 config.SetIter(0);
105 EXPECT_EQ(config.GetIter(), 0);
106 auto connectionPool = ConnectionPool::Create(config, errCode);
107 EXPECT_EQ(errCode, E_OK);
108 }
109
110 HWTEST_F(GdbFuncTest, GdbStore_Func_CreateConnPool03, TestSize.Level1)
111 {
112 int32_t errCode = E_OK;
113 auto config = StoreConfig("test", "/data", DBType::DB_GRAPH);
114 config.SetReadConSize(0);
115 auto connectionPool = ConnectionPool::Create(config, errCode);
116 EXPECT_EQ(errCode, E_OK);
117
118 auto connRead1 = connectionPool->AcquireRef(true);
119 EXPECT_NE(connRead1, nullptr);
120 EXPECT_EQ(connRead1->GetDBType(), DBType::DB_GRAPH);
121 auto connRead2 = connectionPool->AcquireRef(true);
122 EXPECT_NE(connRead2, nullptr);
123 auto connRead3 = connectionPool->AcquireRef(true);
124 EXPECT_NE(connRead3, nullptr);
125
126 auto connWrite1 = connectionPool->AcquireRef(false);
127 EXPECT_NE(connWrite1, nullptr);
128 auto connWrite2 = connectionPool->AcquireRef(false);
129 EXPECT_NE(connWrite2, nullptr);
130 auto connWrite3 = connectionPool->AcquireRef(false);
131 EXPECT_NE(connWrite3, nullptr);
132
133 connWrite1 = nullptr;
134 connWrite2 = nullptr;
135 connWrite3 = nullptr;
136 auto connWrite4 = connectionPool->AcquireRef(false);
137 EXPECT_NE(connWrite4, nullptr);
138
139 connectionPool->CloseAllConnections();
140
141 connRead1 = connectionPool->AcquireRef(true);
142 EXPECT_EQ(connRead1, nullptr);
143
144 connWrite1 = connectionPool->AcquireRef(false);
145 EXPECT_EQ(connWrite1, nullptr);
146 }
147
148 HWTEST_F(GdbFuncTest, GdbStore_Func_CreateConnPool04, TestSize.Level1)
149 {
150 int32_t errCode = E_OK;
151 auto config = StoreConfig("test", "/data", DBType::DB_GRAPH);
152 config.SetReadConSize(65);
153 auto connectionPool = ConnectionPool::Create(config, errCode);
154 EXPECT_EQ(errCode, E_ARGS_READ_CON_OVERLOAD);
155 }
156
157 HWTEST_F(GdbFuncTest, GdbStore_Func_CreateConnPool05, TestSize.Level1)
158 {
159 int32_t errCode = E_OK;
160 auto config = StoreConfig("test", "/data", DBType::DB_GRAPH);
161 auto connectionPool = ConnectionPool::Create(config, errCode);
162 EXPECT_EQ(errCode, E_OK);
163
164 errCode = connectionPool->Dump(true, "header");
165 EXPECT_EQ(errCode, E_OK);
166
167 errCode = connectionPool->RestartReaders();
168 EXPECT_EQ(errCode, E_OK);
169
170 auto connRead1 = connectionPool->AcquireRef(true);
171 EXPECT_NE(connRead1, nullptr);
172 EXPECT_NE(connRead1->GetId(), -1);
173 auto connRead2 = connectionPool->AcquireRef(true);
174 EXPECT_NE(connRead2, nullptr);
175 auto connRead3 = connectionPool->AcquireRef(true);
176 EXPECT_NE(connRead3, nullptr);
177 auto connRead4 = connectionPool->AcquireRef(true);
178 EXPECT_NE(connRead4, nullptr);
179 auto connRead5 = connectionPool->AcquireRef(true);
180 EXPECT_NE(connRead5, nullptr);
181 auto connRead6 = connectionPool->AcquireRef(true);
182 EXPECT_NE(connRead6, nullptr);
183
184 auto connWrite1 = connectionPool->AcquireRef(false);
185 EXPECT_NE(connWrite1, nullptr);
186 auto connWrite2 = connectionPool->AcquireRef(false);
187 EXPECT_EQ(connWrite2, nullptr);
188 auto connWrite3 = connectionPool->AcquireRef(false);
189 EXPECT_EQ(connWrite3, nullptr);
190
191 connWrite1 = nullptr;
192 connWrite2 = nullptr;
193 connWrite3 = nullptr;
194 auto connWrite4 = connectionPool->AcquireRef(false);
195 EXPECT_NE(connWrite4, nullptr);
196
197 connectionPool->CloseAllConnections();
198
199 connRead1 = connectionPool->AcquireRef(true);
200 EXPECT_EQ(connRead1, nullptr);
201
202 connWrite1 = connectionPool->AcquireRef(false);
203 EXPECT_EQ(connWrite1, nullptr);
204 }