5 #if defined(HAVE_CONFIG_H)
9 #include <boost/test/unit_test.hpp>
28 inline std::ostream&
operator<<(std::ostream& os,
const std::pair<const SerializeData, SerializeData>& kv)
31 os <<
"(\"" << std::string_view{
reinterpret_cast<const char*
>(key.data()), key.size()} <<
"\", \""
32 << std::string_view{
reinterpret_cast<const char*
>(key.data()), key.size()} <<
"\")";
40 return AsBytes<const char>({str.data(), str.size()});
61 BOOST_CHECK_EQUAL_COLLECTIONS(actual.begin(), actual.end(), expected.begin(), expected.end());
69 database_filename = data_file.
filename();
75 fs::path test_name =
"test_name.dat";
76 const fs::path datadir = m_args.GetDataDirNet();
77 fs::path file_path = datadir / test_name;
78 std::ofstream f{file_path};
82 std::shared_ptr<BerkeleyEnvironment> env =
GetWalletEnv(file_path, filename);
89 fs::path expected_name =
"wallet.dat";
90 const fs::path datadir = m_args.GetDataDirNet();
93 std::shared_ptr<BerkeleyEnvironment> env =
GetWalletEnv(datadir, filename);
100 fs::path datadir = m_args.GetDataDirNet() /
"1";
101 fs::path datadir_2 = m_args.GetDataDirNet() /
"2";
104 std::shared_ptr<BerkeleyEnvironment> env_1 =
GetWalletEnv(datadir, filename);
105 std::shared_ptr<BerkeleyEnvironment> env_2 =
GetWalletEnv(datadir, filename);
106 std::shared_ptr<BerkeleyEnvironment> env_3 =
GetWalletEnv(datadir_2, filename);
118 std::shared_ptr <BerkeleyEnvironment> env_1_a =
GetWalletEnv(datadir, filename);
119 std::shared_ptr <BerkeleyEnvironment> env_2_a =
GetWalletEnv(datadir_2, filename);
122 std::shared_ptr<BerkeleyEnvironment> env_1_b =
GetWalletEnv(datadir, filename);
123 std::shared_ptr<BerkeleyEnvironment> env_2_b =
GetWalletEnv(datadir_2, filename);
131 std::vector<std::unique_ptr<WalletDatabase>> dbs;
149 std::vector<std::string> prefixes = {
"",
"FIRST",
"SECOND",
"P\xfe\xff",
"P\xff\x01",
"\xff\xff"};
152 std::unique_ptr<DatabaseBatch>
handler =
Assert(database)->MakeBatch();
153 for (
unsigned int i = 0; i < 10; i++) {
154 for (
const auto&
prefix : prefixes) {
160 for (
const auto&
prefix : prefixes) {
163 std::unique_ptr<DatabaseCursor> cursor =
handler->GetNewPrefixCursor(s_prefix);
166 for (
int i = 0; i < 10; i++) {
170 std::string key_back;
172 key >> key_back >> i_back;
175 unsigned int value_back;
192 const MockableData::value_type
201 std::unique_ptr<DatabaseBatch> batch = database->MakeBatch();
202 for (
const auto& [
k, v] : {e, p, ps, f,
fs, ff, ffs}) {
219 std::unique_ptr<DatabaseBatch> batch = database->MakeBatch();
220 std::string key =
"key";
221 std::string value =
"value";
222 std::string value2 =
"value_2";
229 std::string read_value;
239 const std::string key =
"key";
240 const std::string key2 =
"key2";
241 const std::string value =
"value";
242 const std::string value2 =
"value_2";
243 auto make_key = [](std::string type, std::string id) {
return std::make_pair(type,
id); };
246 std::unique_ptr<DatabaseBatch> batch = database->MakeBatch();
250 BOOST_CHECK(batch->Write(make_key(key, value), value));
251 BOOST_CHECK(batch->Write(make_key(key, value2), value2));
252 BOOST_CHECK(batch->Write(make_key(key2, value), value));
253 BOOST_CHECK(batch->Write(make_key(value, key), value));
261 BOOST_CHECK(!batch->Exists(make_key(key, value2)));
271 constexpr
int TEST_SQLITE_ERROR = -999;
273 class DbExecBlocker :
public SQliteExecHandler
276 SQliteExecHandler m_base_exec;
277 std::set<std::string> m_blocked_statements;
279 DbExecBlocker(std::set<std::string> blocked_statements) : m_blocked_statements(blocked_statements) {}
280 int Exec(SQLiteDatabase& database,
const std::string& statement)
override {
281 if (m_blocked_statements.contains(statement))
return TEST_SQLITE_ERROR;
282 return m_base_exec.Exec(database, statement);
290 DatabaseOptions options;
293 std::unique_ptr<SQLiteDatabase> database =
MakeSQLiteDatabase(m_path_root /
"sqlite", options, status, error);
295 std::string key =
"key";
296 std::string value =
"value";
298 std::unique_ptr<SQLiteBatch> batch = std::make_unique<SQLiteBatch>(*database);
303 batch->SetExecHandler(std::make_unique<DbExecBlocker>(std::set<std::string>{
"ROLLBACK TRANSACTION"}));
312 std::string key2 =
"key2";
313 std::unique_ptr<SQLiteBatch> batch2 = std::make_unique<SQLiteBatch>(*database);
321 std::string key =
"key";
322 std::string value =
"value";
323 std::string value2 =
"value_2";
325 DatabaseOptions options;
328 const auto& database =
MakeSQLiteDatabase(m_path_root /
"sqlite", options, status, error);
330 std::unique_ptr<DatabaseBatch>
handler =
Assert(database)->MakeBatch();
339 std::unique_ptr<DatabaseBatch> handler2 =
Assert(database)->MakeBatch();
350 std::string read_value;
#define Assert(val)
Identity function.
fs::path GetDataDirNet() const
Get data directory path with appended network identifier.
Double ended buffer combining vector and stream-like interfaces.
const_iterator begin() const
const_iterator end() const
A Span is an object that can refer to a contiguous sequence of objects.
CONSTEXPR_IF_NOT_DEBUG Span< C > first(std::size_t count) const noexcept
Path class wrapper to block calls to the fs::path(std::string) implicit constructor and the fs::path:...
RAII class that provides access to a WalletDatabase.
virtual std::unique_ptr< DatabaseCursor > GetNewPrefixCursor(Span< const std::byte > prefix)=0
BOOST_AUTO_TEST_SUITE_END()
std::ostream & operator<<(std::ostream &os, const std::pair< const SerializeData, SerializeData > &kv)
Filesystem operations and types.
std::unique_ptr< BerkeleyDatabase > MakeBerkeleyDatabase(const fs::path &path, const DatabaseOptions &options, DatabaseStatus &status, bilingual_str &error)
Return object giving access to Berkeley database at specified path.
static void CheckPrefix(DatabaseBatch &batch, Span< const std::byte > prefix, MockableData expected)
static std::shared_ptr< BerkeleyEnvironment > GetWalletEnv(const fs::path &path, fs::path &database_filename)
static SerializeData StringData(std::string_view str)
std::unique_ptr< SQLiteDatabase > MakeSQLiteDatabase(const fs::path &path, const DatabaseOptions &options, DatabaseStatus &status, bilingual_str &error)
static std::vector< std::unique_ptr< WalletDatabase > > TestDatabases(const fs::path &path_root)
fs::path BDBDataFile(const fs::path &wallet_path)
std::unique_ptr< WalletDatabase > CreateMockableWalletDatabase(MockableData records)
std::shared_ptr< BerkeleyEnvironment > GetBerkeleyEnv(const fs::path &env_directory, bool use_shared_memory)
Get BerkeleyEnvironment given a directory path.
BOOST_AUTO_TEST_CASE(bnb_search_test)
static Span< const std::byte > StringBytes(std::string_view str)
std::map< SerializeData, SerializeData, std::less<> > MockableData
#define BOOST_CHECK_EQUAL(v1, v2)
#define BOOST_CHECK(expr)
bool(* handler)(const std::any &context, HTTPRequest *req, const std::string &strReq)
std::vector< std::byte, zero_after_free_allocator< std::byte > > SerializeData
Byte-vector that clears its contents before deletion.