Database System 0.1.0
Advanced C++20 Database System with Multi-Backend Support
Loading...
Searching...
No Matches
Classes | Functions
sqlite_backend_test.cpp File Reference
#include <atomic>
#include <chrono>
#include <cstdio>
#include <filesystem>
#include <gtest/gtest.h>
#include <memory>
#include <thread>
#include <vector>
#include "database/backends/sqlite_backend.h"
#include "database/core/database_backend.h"
Include dependency graph for sqlite_backend_test.cpp:

Go to the source code of this file.

Classes

class  SQLiteBackendTest
 Test fixture for SQLite backend tests. More...
 

Functions

 TEST_F (SQLiteBackendTest, DatabaseTypeReturnsSQLite)
 
 TEST_F (SQLiteBackendTest, ConnectToMemoryDatabase)
 
 TEST_F (SQLiteBackendTest, ConnectToFileDatabase)
 
 TEST_F (SQLiteBackendTest, ShutdownWithoutConnection)
 
 TEST_F (SQLiteBackendTest, ShutdownAfterConnection)
 
 TEST_F (SQLiteBackendTest, ExecuteQueryWithoutConnection)
 
 TEST_F (SQLiteBackendTest, CreateTableQuery)
 
 TEST_F (SQLiteBackendTest, InsertQueryWithoutConnection)
 
 TEST_F (SQLiteBackendTest, InsertSingleRow)
 
 TEST_F (SQLiteBackendTest, SelectQueryWithoutConnection)
 
 TEST_F (SQLiteBackendTest, SelectFromEmptyTable)
 
 TEST_F (SQLiteBackendTest, SelectWithCondition)
 
 TEST_F (SQLiteBackendTest, UpdateQueryWithoutConnection)
 
 TEST_F (SQLiteBackendTest, UpdateSingleRow)
 
 TEST_F (SQLiteBackendTest, DeleteQueryWithoutConnection)
 
 TEST_F (SQLiteBackendTest, DeleteSingleRow)
 
 TEST_F (SQLiteBackendTest, TransactionCommit)
 
 TEST_F (SQLiteBackendTest, TransactionRollback)
 
 TEST_F (SQLiteBackendTest, ConcurrentReads)
 
 TEST_F (SQLiteBackendTest, SpecialCharactersInData)
 
 TEST_F (SQLiteBackendTest, UnicodeData)
 
int main (int argc, char **argv)
 

Function Documentation

◆ main()

int main ( int argc,
char ** argv )

Definition at line 378 of file sqlite_backend_test.cpp.

378 {
379 ::testing::InitGoogleTest(&argc, argv);
380 return RUN_ALL_TESTS();
381}

◆ TEST_F() [1/21]

TEST_F ( SQLiteBackendTest ,
ConcurrentReads  )

Definition at line 304 of file sqlite_backend_test.cpp.

304 {
305#ifdef USE_SQLITE
306 EXPECT_TRUE(connectToMemory());
307 EXPECT_TRUE(createTestTable());
308
309 for (int i = 0; i < 100; ++i) {
310 backend_->execute_query(
311 "INSERT INTO test_table (name, value) VALUES ('item" +
312 std::to_string(i) + "', " + std::to_string(i * 1.5) + ")");
313 }
314
315 std::atomic<int> success_count{0};
316 std::vector<std::thread> threads;
317
318 for (int t = 0; t < 10; ++t) {
319 threads.emplace_back([this, &success_count]() {
320 for (int i = 0; i < 10; ++i) {
321 auto result =
322 backend_->select_query("SELECT COUNT(*) as cnt FROM test_table");
323 if (result.is_ok() && std::get<int64_t>(result.value()[0].at("cnt")) == 100) {
324 success_count++;
325 }
326 }
327 });
328 }
329
330 for (auto &t : threads) {
331 t.join();
332 }
333
334 EXPECT_EQ(success_count.load(), 100);
335#else
336 GTEST_SKIP() << "SQLite support not compiled";
337#endif
338}

◆ TEST_F() [2/21]

TEST_F ( SQLiteBackendTest ,
ConnectToFileDatabase  )

Definition at line 97 of file sqlite_backend_test.cpp.

97 {
98#ifdef USE_SQLITE
99 EXPECT_TRUE(connectToFile());
100 EXPECT_TRUE(std::filesystem::exists(test_db_path_));
101#else
102 GTEST_SKIP() << "SQLite support not compiled";
103#endif
104}

◆ TEST_F() [3/21]

TEST_F ( SQLiteBackendTest ,
ConnectToMemoryDatabase  )

Definition at line 88 of file sqlite_backend_test.cpp.

88 {
89#ifdef USE_SQLITE
90 EXPECT_TRUE(connectToMemory());
91 EXPECT_TRUE(backend_->is_initialized());
92#else
93 GTEST_SKIP() << "SQLite support not compiled";
94#endif
95}

◆ TEST_F() [4/21]

TEST_F ( SQLiteBackendTest ,
CreateTableQuery  )

Definition at line 129 of file sqlite_backend_test.cpp.

129 {
130#ifdef USE_SQLITE
131 EXPECT_TRUE(connectToMemory());
132 EXPECT_TRUE(backend_->execute_query(
133 "CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT)").is_ok());
134#else
135 GTEST_SKIP() << "SQLite support not compiled";
136#endif
137}

◆ TEST_F() [5/21]

TEST_F ( SQLiteBackendTest ,
DatabaseTypeReturnsSQLite  )

Definition at line 80 of file sqlite_backend_test.cpp.

80 {
81 EXPECT_EQ(backend_->type(), database_types::sqlite);
82}

◆ TEST_F() [6/21]

TEST_F ( SQLiteBackendTest ,
DeleteQueryWithoutConnection  )

Definition at line 233 of file sqlite_backend_test.cpp.

233 {
234 auto result = backend_->execute_query("DELETE FROM test WHERE id = 1");
235 EXPECT_FALSE(result.is_ok());
236}

◆ TEST_F() [7/21]

TEST_F ( SQLiteBackendTest ,
DeleteSingleRow  )

Definition at line 238 of file sqlite_backend_test.cpp.

238 {
239#ifdef USE_SQLITE
240 EXPECT_TRUE(connectToMemory());
241 EXPECT_TRUE(createTestTable());
242
243 backend_->execute_query(
244 "INSERT INTO test_table (name, value) VALUES ('item1', 10.0)");
245 backend_->execute_query(
246 "INSERT INTO test_table (name, value) VALUES ('item2', 20.0)");
247
248 auto result =
249 backend_->execute_query("DELETE FROM test_table WHERE id = 1");
250 EXPECT_TRUE(result.is_ok());
251#else
252 GTEST_SKIP() << "SQLite support not compiled";
253#endif
254}

◆ TEST_F() [8/21]

TEST_F ( SQLiteBackendTest ,
ExecuteQueryWithoutConnection  )

Definition at line 125 of file sqlite_backend_test.cpp.

125 {
126 EXPECT_FALSE(backend_->execute_query("CREATE TABLE test (id INTEGER)").is_ok());
127}

◆ TEST_F() [9/21]

TEST_F ( SQLiteBackendTest ,
InsertQueryWithoutConnection  )

Definition at line 143 of file sqlite_backend_test.cpp.

143 {
144 auto result = backend_->execute_query("INSERT INTO test VALUES (1, 'test')");
145 EXPECT_FALSE(result.is_ok());
146}

◆ TEST_F() [10/21]

TEST_F ( SQLiteBackendTest ,
InsertSingleRow  )

Definition at line 148 of file sqlite_backend_test.cpp.

148 {
149#ifdef USE_SQLITE
150 EXPECT_TRUE(connectToMemory());
151 EXPECT_TRUE(createTestTable());
152
153 auto result = backend_->execute_query(
154 "INSERT INTO test_table (name, value) VALUES ('item1', 10.5)");
155 EXPECT_TRUE(result.is_ok());
156#else
157 GTEST_SKIP() << "SQLite support not compiled";
158#endif
159}

◆ TEST_F() [11/21]

TEST_F ( SQLiteBackendTest ,
SelectFromEmptyTable  )

Definition at line 170 of file sqlite_backend_test.cpp.

170 {
171#ifdef USE_SQLITE
172 EXPECT_TRUE(connectToMemory());
173 EXPECT_TRUE(createTestTable());
174
175 auto result = backend_->select_query("SELECT * FROM test_table");
176 EXPECT_TRUE(result.is_ok());
177 EXPECT_TRUE(result.value().empty());
178#else
179 GTEST_SKIP() << "SQLite support not compiled";
180#endif
181}

◆ TEST_F() [12/21]

TEST_F ( SQLiteBackendTest ,
SelectQueryWithoutConnection  )

Definition at line 165 of file sqlite_backend_test.cpp.

165 {
166 auto result = backend_->select_query("SELECT * FROM test");
167 EXPECT_FALSE(result.is_ok());
168}

◆ TEST_F() [13/21]

TEST_F ( SQLiteBackendTest ,
SelectWithCondition  )

Definition at line 183 of file sqlite_backend_test.cpp.

183 {
184#ifdef USE_SQLITE
185 EXPECT_TRUE(connectToMemory());
186 EXPECT_TRUE(createTestTable());
187
188 backend_->execute_query(
189 "INSERT INTO test_table (name, value) VALUES ('item1', 10.0)");
190 backend_->execute_query(
191 "INSERT INTO test_table (name, value) VALUES ('item2', 20.0)");
192 backend_->execute_query(
193 "INSERT INTO test_table (name, value) VALUES ('item3', 30.0)");
194
195 auto result =
196 backend_->select_query("SELECT * FROM test_table WHERE value > 15.0");
197 EXPECT_TRUE(result.is_ok());
198 EXPECT_EQ(result.value().size(), 2u);
199#else
200 GTEST_SKIP() << "SQLite support not compiled";
201#endif
202}

◆ TEST_F() [14/21]

TEST_F ( SQLiteBackendTest ,
ShutdownAfterConnection  )

Definition at line 111 of file sqlite_backend_test.cpp.

111 {
112#ifdef USE_SQLITE
113 EXPECT_TRUE(connectToMemory());
114 EXPECT_TRUE(backend_->shutdown().is_ok());
115 EXPECT_FALSE(backend_->is_initialized());
116#else
117 GTEST_SKIP() << "SQLite support not compiled";
118#endif
119}

◆ TEST_F() [15/21]

TEST_F ( SQLiteBackendTest ,
ShutdownWithoutConnection  )

Definition at line 106 of file sqlite_backend_test.cpp.

106 {
107 auto result = backend_->shutdown();
108 EXPECT_TRUE(result.is_ok());
109}

◆ TEST_F() [16/21]

TEST_F ( SQLiteBackendTest ,
SpecialCharactersInData  )

Definition at line 344 of file sqlite_backend_test.cpp.

344 {
345#ifdef USE_SQLITE
346 EXPECT_TRUE(connectToMemory());
347 EXPECT_TRUE(createTestTable());
348
349 backend_->execute_query(
350 "INSERT INTO test_table (name, value) VALUES ('test''s data', 10.0)");
351
352 auto result = backend_->select_query("SELECT name FROM test_table");
353 ASSERT_TRUE(result.is_ok());
354 ASSERT_EQ(result.value().size(), 1u);
355 EXPECT_EQ(std::get<std::string>(result.value()[0].at("name")), "test's data");
356#else
357 GTEST_SKIP() << "SQLite support not compiled";
358#endif
359}
ASSERT_EQ
#define ASSERT_EQ(expected, actual, message)
Definition test_connection_string_builder.cpp:38
ASSERT_TRUE
#define ASSERT_TRUE(condition, message)
Definition test_connection_string_builder.cpp:25

References ASSERT_EQ, and ASSERT_TRUE.

◆ TEST_F() [17/21]

TEST_F ( SQLiteBackendTest ,
TransactionCommit  )

Definition at line 260 of file sqlite_backend_test.cpp.

260 {
261#ifdef USE_SQLITE
262 EXPECT_TRUE(connectToMemory());
263 EXPECT_TRUE(createTestTable());
264
265 EXPECT_TRUE(backend_->begin_transaction().is_ok());
266 EXPECT_TRUE(backend_->in_transaction());
267 backend_->execute_query(
268 "INSERT INTO test_table (name, value) VALUES ('trans_item', 50.0)");
269 EXPECT_TRUE(backend_->commit_transaction().is_ok());
270 EXPECT_FALSE(backend_->in_transaction());
271
272 auto result = backend_->select_query(
273 "SELECT * FROM test_table WHERE name = 'trans_item'");
274 EXPECT_TRUE(result.is_ok());
275 EXPECT_EQ(result.value().size(), 1u);
276#else
277 GTEST_SKIP() << "SQLite support not compiled";
278#endif
279}

◆ TEST_F() [18/21]

TEST_F ( SQLiteBackendTest ,
TransactionRollback  )

Definition at line 281 of file sqlite_backend_test.cpp.

281 {
282#ifdef USE_SQLITE
283 EXPECT_TRUE(connectToMemory());
284 EXPECT_TRUE(createTestTable());
285
286 EXPECT_TRUE(backend_->begin_transaction().is_ok());
287 backend_->execute_query(
288 "INSERT INTO test_table (name, value) VALUES ('rollback_item', 50.0)");
289 EXPECT_TRUE(backend_->rollback_transaction().is_ok());
290
291 auto result = backend_->select_query(
292 "SELECT * FROM test_table WHERE name = 'rollback_item'");
293 EXPECT_TRUE(result.is_ok());
294 EXPECT_TRUE(result.value().empty());
295#else
296 GTEST_SKIP() << "SQLite support not compiled";
297#endif
298}

◆ TEST_F() [19/21]

TEST_F ( SQLiteBackendTest ,
UnicodeData  )

Definition at line 361 of file sqlite_backend_test.cpp.

361 {
362#ifdef USE_SQLITE
363 EXPECT_TRUE(connectToMemory());
364 EXPECT_TRUE(createTestTable());
365
366 backend_->execute_query(
367 "INSERT INTO test_table (name, value) VALUES ('한글테스트', 10.0)");
368
369 auto result = backend_->select_query("SELECT name FROM test_table");
370 ASSERT_TRUE(result.is_ok());
371 ASSERT_EQ(result.value().size(), 1u);
372 EXPECT_EQ(std::get<std::string>(result.value()[0].at("name")), "한글테스트");
373#else
374 GTEST_SKIP() << "SQLite support not compiled";
375#endif
376}

References ASSERT_EQ, and ASSERT_TRUE.

◆ TEST_F() [20/21]

TEST_F ( SQLiteBackendTest ,
UpdateQueryWithoutConnection  )

Definition at line 208 of file sqlite_backend_test.cpp.

208 {
209 auto result = backend_->execute_query("UPDATE test SET name = 'new'");
210 EXPECT_FALSE(result.is_ok());
211}

◆ TEST_F() [21/21]

TEST_F ( SQLiteBackendTest ,
UpdateSingleRow  )

Definition at line 213 of file sqlite_backend_test.cpp.

213 {
214#ifdef USE_SQLITE
215 EXPECT_TRUE(connectToMemory());
216 EXPECT_TRUE(createTestTable());
217
218 backend_->execute_query(
219 "INSERT INTO test_table (name, value) VALUES ('old_name', 10.0)");
220
221 auto result = backend_->execute_query(
222 "UPDATE test_table SET name = 'new_name' WHERE id = 1");
223 EXPECT_TRUE(result.is_ok());
224#else
225 GTEST_SKIP() << "SQLite support not compiled";
226#endif
227}