BlockStorage/repertory
1
0
Fork 0
Code Issues 7 Pull Requests Releases 6 Wiki Activity

[Unit Test] SQLite mini-ORM unit tests and cleanup #14
All checks were successful
BlockStorage/repertory/pipeline/head This commit looks good
Details

Browse Source
This commit is contained in:
Scott E. Graves 2024-10-01 14:21:23 -05:00
parent 62a75bcddd
commit a523d1ca66
1 changed files with 94 additions and 243 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

337
repertory/repertory_test/src/database_test.cpp
View File

@ -29,267 +29,118 @@
#include "utils/path.hpp" #include "utils/path.hpp"
namespace repertory { namespace repertory {
TEST(database, db_delete_query) { class database_test : public ::testing::Test {
console_consumer consumer1; public:
event_system::instance().start(); static console_consumer cs;
{ db::db3_t db3;
db::db3_t db3;
{
sqlite3 *db3_ptr{nullptr};
auto res = sqlite3_open_v2(
utils::path::combine(test::get_test_input_dir(), {"test.db3"})
.c_str(),
&db3_ptr, SQLITE_OPEN_READWRITE, nullptr);
ASSERT_EQ(SQLITE_OK, res);
ASSERT_TRUE(db3_ptr != nullptr);
db3.reset(db3_ptr); void SetUp() override {
} event_system::instance().start();
auto query = db::db_delete{*db3.get(), "table"}; sqlite3 *db3_ptr{nullptr};
auto query_str = query.dump(); auto res = sqlite3_open_v2(
std::cout << query_str << std::endl; utils::path::combine(test::get_test_input_dir(), {"test.db3"}).c_str(),
EXPECT_STREQ(R"(DELETE FROM "table";)", query_str.c_str()); &db3_ptr, SQLITE_OPEN_READWRITE, nullptr);
ASSERT_EQ(SQLITE_OK, res);
ASSERT_TRUE(db3_ptr != nullptr);
db3.reset(db3_ptr);
} }
event_system::instance().stop(); void TearDown() override {
db3.reset();
event_system::instance().stop();
}
};
TEST_F(database_test, db_delete_query) {
auto query = db::db_delete{*db3.get(), "table"};
auto query_str = query.dump();
std::cout << query_str << std::endl;
EXPECT_STREQ(R"(DELETE FROM "table";)", query_str.c_str());
} }
TEST(database, db_delete_where_query) { TEST_F(database_test, db_delete_where_query) {
console_consumer consumer1; auto query = db::db_delete{*db3.get(), "table"}
event_system::instance().start(); .where("column1")
{ .equals("test1")
db::db3_t db3; .and_where("column2")
{ .equals("test2");
sqlite3 *db3_ptr{nullptr}; auto query_str = query.dump();
auto res = sqlite3_open_v2( std::cout << query_str << std::endl;
utils::path::combine(test::get_test_input_dir(), {"test.db3"}) EXPECT_STREQ(R"(DELETE FROM "table" WHERE ("column1"=?1 AND "column2"=?2);)",
.c_str(), query_str.c_str());
&db3_ptr, SQLITE_OPEN_READWRITE, nullptr);
ASSERT_EQ(SQLITE_OK, res);
ASSERT_TRUE(db3_ptr != nullptr);
db3.reset(db3_ptr);
}
auto query = db::db_delete{*db3.get(), "table"}
.where("column1")
.equals("test1")
.and_where("column2")
.equals("test2");
auto query_str = query.dump();
std::cout << query_str << std::endl;
EXPECT_STREQ(
R"(DELETE FROM "table" WHERE ("column1"=?1 AND "column2"=?2);)",
query_str.c_str());
}
event_system::instance().stop();
} }
TEST(database, db_insert_query) { TEST_F(database_test, db_insert_query) {
console_consumer consumer1; auto query = db::db_insert{*db3.get(), "table"}
event_system::instance().start(); .column_value("column1", "test9")
{ .column_value("column2", "test9");
db::db3_t db3; auto query_str = query.dump();
{ std::cout << query_str << std::endl;
sqlite3 *db3_ptr{nullptr}; EXPECT_STREQ(R"(INSERT INTO "table" ("column1", "column2") VALUES (?1, ?2);)",
auto res = sqlite3_open_v2( query_str.c_str());
utils::path::combine(test::get_test_input_dir(), {"test.db3"})
.c_str(),
&db3_ptr, SQLITE_OPEN_READWRITE, nullptr);
ASSERT_EQ(SQLITE_OK, res);
ASSERT_TRUE(db3_ptr != nullptr);
db3.reset(db3_ptr);
}
auto query = db::db_insert{*db3.get(), "table"}
.column_value("column1", "test9")
.column_value("column2", "test9");
auto query_str = query.dump();
std::cout << query_str << std::endl;
EXPECT_STREQ(
R"(INSERT INTO "table" ("column1", "column2") VALUES (?1, ?2);)",
query_str.c_str());
}
event_system::instance().stop();
} }
TEST(database, db_insert_or_replace_query) { TEST_F(database_test, db_insert_or_replace_query) {
console_consumer consumer1; auto query = db::db_insert{*db3.get(), "table"}
event_system::instance().start(); .or_replace()
{ .column_value("column1", "test1")
db::db3_t db3; .column_value("column2", "test2");
{ auto query_str = query.dump();
sqlite3 *db3_ptr{nullptr}; std::cout << query_str << std::endl;
auto res = sqlite3_open_v2( EXPECT_STREQ(
utils::path::combine(test::get_test_input_dir(), {"test.db3"}) R"(INSERT OR REPLACE INTO "table" ("column1", "column2") VALUES (?1, ?2);)",
.c_str(), query_str.c_str());
&db3_ptr, SQLITE_OPEN_READWRITE, nullptr);
ASSERT_EQ(SQLITE_OK, res);
ASSERT_TRUE(db3_ptr != nullptr);
db3.reset(db3_ptr);
}
auto query = db::db_insert{*db3.get(), "table"}
.or_replace()
.column_value("column1", "test1")
.column_value("column2", "test2");
auto query_str = query.dump();
std::cout << query_str << std::endl;
EXPECT_STREQ(
R"(INSERT OR REPLACE INTO "table" ("column1", "column2") VALUES (?1, ?2);)",
query_str.c_str());
}
event_system::instance().stop();
} }
TEST(database, db_select_query) { TEST_F(database_test, db_select_query) {
console_consumer consumer1; auto query = db::db_select{*db3.get(), "table"};
event_system::instance().start(); auto query_str = query.dump();
{ std::cout << query_str << std::endl;
db::db3_t db3; EXPECT_STREQ(R"(SELECT * FROM "table";)", query_str.c_str());
{
sqlite3 *db3_ptr{nullptr};
auto res = sqlite3_open_v2(
utils::path::combine(test::get_test_input_dir(), {"test.db3"})
.c_str(),
&db3_ptr, SQLITE_OPEN_READWRITE, nullptr);
ASSERT_EQ(SQLITE_OK, res);
ASSERT_TRUE(db3_ptr != nullptr);
db3.reset(db3_ptr);
}
auto query = db::db_select{*db3.get(), "table"};
auto query_str = query.dump();
std::cout << query_str << std::endl;
EXPECT_STREQ(R"(SELECT * FROM "table";)", query_str.c_str());
}
event_system::instance().stop();
} }
TEST(database, db_select_where_query) { TEST_F(database_test, db_select_where_query) {
console_consumer consumer1; auto query = db::db_select{*db3.get(), "table"}
event_system::instance().start(); .where("column1")
{ .equals("test1")
db::db3_t db3; .and_where("column2")
{ .equals("test2");
sqlite3 *db3_ptr{nullptr}; auto query_str = query.dump();
auto res = sqlite3_open_v2( std::cout << query_str << std::endl;
utils::path::combine(test::get_test_input_dir(), {"test.db3"}) EXPECT_STREQ(
.c_str(), R"(SELECT * FROM "table" WHERE ("column1"=?1 AND "column2"=?2);)",
&db3_ptr, SQLITE_OPEN_READWRITE, nullptr); query_str.c_str());
ASSERT_EQ(SQLITE_OK, res);
ASSERT_TRUE(db3_ptr != nullptr);
db3.reset(db3_ptr);
}
auto query = db::db_select{*db3.get(), "table"}
.where("column1")
.equals("test1")
.and_where("column2")
.equals("test2");
auto query_str = query.dump();
std::cout << query_str << std::endl;
EXPECT_STREQ(
R"(SELECT * FROM "table" WHERE ("column1"=?1 AND "column2"=?2);)",
query_str.c_str());
// auto res = query.go();
//
// EXPECT_TRUE(res.ok());
// EXPECT_TRUE(res.has_row());
// std::size_t row_count{};
// while (res.has_row()) {
// std::optional<db::db_select::row> row;
// EXPECT_TRUE(res.get_row(row));
// EXPECT_TRUE(row.has_value());
// if (row.has_value()) {
// for (const auto &column : row.value().get_columns()) {
// std::cout << column.get_index() << ':';
// std::cout << column.get_name() << ':';
// std::cout << column.get_value<std::string>() << std::endl;
// }
// }
// ++row_count;
// }
// EXPECT_EQ(std::size_t(1U), row_count);
}
event_system::instance().stop();
} }
TEST(database, db_select_columns_query) { TEST_F(database_test, db_select_columns_query) {
console_consumer consumer1; auto query = db::db_select{*db3.get(), "table"}
event_system::instance().start(); .column("column1")
{ .column("column2")
db::db3_t db3; .where("column1")
{ .equals("test1")
sqlite3 *db3_ptr{nullptr}; .and_where("column2")
auto res = sqlite3_open_v2( .equals("test2");
utils::path::combine(test::get_test_input_dir(), {"test.db3"}) auto query_str = query.dump();
.c_str(), std::cout << query_str << std::endl;
&db3_ptr, SQLITE_OPEN_READWRITE, nullptr); EXPECT_STREQ(
ASSERT_EQ(SQLITE_OK, res); R"(SELECT column1, column2 FROM "table" WHERE ("column1"=?1 AND "column2"=?2);)",
ASSERT_TRUE(db3_ptr != nullptr); query_str.c_str());
db3.reset(db3_ptr);
}
auto query = db::db_select{*db3.get(), "table"}
.column("column1")
.column("column2")
.where("column1")
.equals("test1")
.and_where("column2")
.equals("test2");
auto query_str = query.dump();
std::cout << query_str << std::endl;
EXPECT_STREQ(
R"(SELECT column1, column2 FROM "table" WHERE ("column1"=?1 AND "column2"=?2);)",
query_str.c_str());
}
event_system::instance().stop();
} }
TEST(database, db_update_query) { TEST_F(database_test, db_update_query) {
console_consumer consumer1; auto query = db::db_update{*db3.get(), "table"}
event_system::instance().start(); .column_value("column1", "moose")
{ .where("column1")
db::db3_t db3; .equals("test1")
{ .and_where("column2")
sqlite3 *db3_ptr{nullptr}; .equals("test2");
auto res = sqlite3_open_v2( auto query_str = query.dump();
utils::path::combine(test::get_test_input_dir(), {"test.db3"}) std::cout << query_str << std::endl;
.c_str(), EXPECT_STREQ(
&db3_ptr, SQLITE_OPEN_READWRITE, nullptr); R"(UPDATE "table" SET "column1"=?1 WHERE ("column1"=?2 AND "column2"=?3);)",
ASSERT_EQ(SQLITE_OK, res); query_str.c_str());
ASSERT_TRUE(db3_ptr != nullptr);
db3.reset(db3_ptr);
}
auto query = db::db_update{*db3.get(), "table"}
.column_value("column1", "moose")
.where("column1")
.equals("test1")
.and_where("column2")
.equals("test2");
auto query_str = query.dump();
std::cout << query_str << std::endl;
EXPECT_STREQ(
R"(UPDATE "table" SET "column1"=?1 WHERE ("column1"=?2 AND "column2"=?3);)",
query_str.c_str());
}
event_system::instance().stop();
} }
// auto res = query.go(); // auto res = query.go();