readme and some test

Ferenc Szontágh

2024-06-27 3ac954922108b07fb3f7a7ce1c727bfcfad8b263

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
#include "RocksDBWrapper.h"
#include <gtest/gtest.h>
#include <string>
#include <filesystem>
 
struct TestStruct
{
    int id;
    std::string name;
    double value;
 
    DEFINE_SERIALIZABLE(TestStruct, id, name, value);
};
 
class RocksDBWrapperTest : public ::testing::Test
{
protected:
    RocksDBWrapper *db;
    std::string db_path = "/tmp/testdb";
    std::string index_path = "/tmp/testindex";
 
    void SetUp() override
    {
        db = new RocksDBWrapper(db_path, index_path);
    }
 
    void TearDown() override
    {
        delete db;
        // Clean up the database files after each test
        std::filesystem::remove_all(db_path);
        std::filesystem::remove_all(index_path);
    }
};
 
TEST_F(RocksDBWrapperTest, StoreAndRetrieve)
{
    TestStruct original{1, "Test", 3.14};
    db->store("test_key", original);
 
    TestStruct retrieved;
    bool found = db->get("test_key", retrieved);
 
    ASSERT_TRUE(found);
    EXPECT_EQ(original.id, retrieved.id);
    EXPECT_EQ(original.name, retrieved.name);
    EXPECT_DOUBLE_EQ(original.value, retrieved.value);
}
 
TEST_F(RocksDBWrapperTest, KeyExists)
{
    TestStruct original{2, "AnotherTest", 2.718};
    db->store("another_key", original);
 
    ASSERT_TRUE(db->keyExists("another_key"));
    ASSERT_FALSE(db->keyExists("nonexistent_key"));
}
 
TEST_F(RocksDBWrapperTest, SearchByMember)
{
    TestStruct ts1{1, "Alpha", 1.1};
    TestStruct ts2{2, "Beta", 2.2};
    TestStruct ts3{3, "Gamma", 3.3};
 
    db->store("key1", ts1);
    db->store("key2", ts2);
    db->store("key3", ts3);
 
    auto keys = db->search<TestStruct>("name", "Beta");
    ASSERT_EQ(keys.size(), 1);
    EXPECT_EQ(keys[0], "key2");
}
 
TEST_F(RocksDBWrapperTest, SearchText)
{
    TestStruct ts1{1, "Alpha", 1.1};
    TestStruct ts2{2, "Beta", 2.2};
    TestStruct ts3{3, "Gamma", 3.3};
 
    db->store("key1", ts1);
    db->store("key2", ts2);
    db->store("key3", ts3);
 
    std::vector<TestStruct> results;
    db->search_text("Bet*", results);
 
    ASSERT_EQ(results.size(), 1);
    EXPECT_EQ(results[0].name, "Beta");
}
 
TEST_F(RocksDBWrapperTest, ConditionalSearch)
{
    TestStruct ts1{1, "Alpha", 1.1};
    TestStruct ts2{2, "Beta", 2.2};
    TestStruct ts3{3, "Gamma", 3.3};
 
    db->store("key1", ts1);
    db->store("key2", ts2);
    db->store("key3", ts3);
 
    std::vector<TestStruct> results;
    db->search_conditional<TestStruct>(results, [](const TestStruct &s)
                                       { return s.value > 2.0; });
 
    ASSERT_EQ(results.size(), 2);
    EXPECT_EQ(results[0].name, "Beta");
    EXPECT_EQ(results[1].name, "Gamma");
}
 
int main(int argc, char **argv)
{
    ::testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}