071df2f439
* Split queries into system and data queries * System queries are sequentially executed and generate separate transaction deltas * System transaction try locks for 100ms * last_commited_system_ts saved to DBMS durability * Replicating CREATE/DROP DATABASE * Sending a system snapshot if REPLICA behind * Passing a copy of the gatekeeper::access as std::any to all functions that could call an async execution * Removed delete_on_drop flag (we now always delete on drop) * Using UUID as the directory name for databases * DBMS durability update (added versioning and salient information) * Automatic migration from previous version * Interpreter can run some queries without a target database * SHOW REPLICA returns the status of the currently active DB * Returning UUID instead of db name in the RPC responses * Using UUIDs for database specification in RPC (not name) * FrequentCheck forces update on reconnect * TimestampRpc will detect if a replica is behind, and will update client's state * Safer SLK reads * Split SHOW DATABASES in two SHOW DATABASES (list of current databases) and SHOW DATABASE a single string naming the current database --------- Co-authored-by: Gareth Lloyd <gareth.lloyd@memgraph.io>
105 lines
3.9 KiB
C++
105 lines
3.9 KiB
C++
// Copyright 2023 Memgraph Ltd.
|
|
//
|
|
// Use of this software is governed by the Business Source License
|
|
// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
|
|
// License, and you may not use this file except in compliance with the Business Source License.
|
|
//
|
|
// As of the Change Date specified in that file, in accordance with
|
|
// the Business Source License, use of this software will be governed
|
|
// by the Apache License, Version 2.0, included in the file
|
|
// licenses/APL.txt.
|
|
|
|
#include "query/auth_query_handler.hpp"
|
|
|
|
#include <gmock/gmock.h>
|
|
#include <gtest/gtest.h>
|
|
#include <filesystem>
|
|
#include <system_error>
|
|
|
|
#include "dbms/constants.hpp"
|
|
#include "dbms/dbms_handler.hpp"
|
|
#include "dbms/global.hpp"
|
|
#include "glue/auth_checker.hpp"
|
|
#include "glue/auth_handler.hpp"
|
|
#include "query/config.hpp"
|
|
#include "query/interpreter.hpp"
|
|
#include "storage/v2/config.hpp"
|
|
|
|
// Global
|
|
std::filesystem::path storage_directory{std::filesystem::temp_directory_path() / "MG_test_unit_dbms_handler_community"};
|
|
static memgraph::storage::Config storage_conf;
|
|
std::unique_ptr<memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock>> auth;
|
|
|
|
// Let this be global so we can test it different states throughout
|
|
|
|
class TestEnvironment : public ::testing::Environment {
|
|
public:
|
|
static memgraph::dbms::DbmsHandler *get() { return ptr_.get(); }
|
|
|
|
void SetUp() override {
|
|
// Setup config
|
|
memgraph::storage::UpdatePaths(storage_conf, storage_directory);
|
|
storage_conf.durability.snapshot_wal_mode =
|
|
memgraph::storage::Config::Durability::SnapshotWalMode::PERIODIC_SNAPSHOT_WITH_WAL;
|
|
// Clean storage directory (running multiple parallel test, run only if the first process)
|
|
if (std::filesystem::exists(storage_directory)) {
|
|
memgraph::utils::OutputFile lock_file_handle_;
|
|
lock_file_handle_.Open(storage_directory / ".lock", memgraph::utils::OutputFile::Mode::OVERWRITE_EXISTING);
|
|
if (lock_file_handle_.AcquireLock()) {
|
|
std::filesystem::remove_all(storage_directory);
|
|
}
|
|
}
|
|
auth =
|
|
std::make_unique<memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock>>(
|
|
storage_directory / "auth");
|
|
ptr_ = std::make_unique<memgraph::dbms::DbmsHandler>(storage_conf);
|
|
}
|
|
|
|
void TearDown() override {
|
|
ptr_.reset();
|
|
auth.reset();
|
|
std::filesystem::remove_all(storage_directory);
|
|
}
|
|
|
|
static std::unique_ptr<memgraph::dbms::DbmsHandler> ptr_;
|
|
};
|
|
|
|
std::unique_ptr<memgraph::dbms::DbmsHandler> TestEnvironment::ptr_ = nullptr;
|
|
|
|
class DBMS_Handler : public testing::Test {};
|
|
using DBMS_HandlerDeath = DBMS_Handler;
|
|
|
|
TEST(DBMS_Handler, Init) {
|
|
// Check that the default db has been created successfully
|
|
std::vector<std::string> dirs = {"snapshots", "streams", "triggers", "wal"};
|
|
for (const auto &dir : dirs)
|
|
ASSERT_TRUE(std::filesystem::exists(storage_directory / dir)) << (storage_directory / dir);
|
|
auto &dbms = *TestEnvironment::get();
|
|
{
|
|
const auto all = dbms.All();
|
|
ASSERT_EQ(all.size(), 1);
|
|
ASSERT_EQ(all[0], memgraph::dbms::kDefaultDB);
|
|
}
|
|
}
|
|
|
|
TEST(DBMS_Handler, Get) {
|
|
auto &dbms = *TestEnvironment::get();
|
|
auto default_db = dbms.Get();
|
|
ASSERT_TRUE(default_db);
|
|
ASSERT_TRUE(default_db->storage() != nullptr);
|
|
ASSERT_TRUE(default_db->streams() != nullptr);
|
|
ASSERT_TRUE(default_db->trigger_store() != nullptr);
|
|
ASSERT_TRUE(default_db->thread_pool() != nullptr);
|
|
ASSERT_EQ(default_db->storage()->name(), memgraph::dbms::kDefaultDB);
|
|
auto conf = storage_conf;
|
|
conf.salient.name = memgraph::dbms::kDefaultDB;
|
|
ASSERT_EQ(default_db->storage()->config_, conf);
|
|
}
|
|
|
|
int main(int argc, char *argv[]) {
|
|
::testing::InitGoogleTest(&argc, argv);
|
|
// gtest takes ownership of the TestEnvironment ptr - we don't delete it.
|
|
::testing::AddGlobalTestEnvironment(new TestEnvironment);
|
|
return RUN_ALL_TESTS();
|
|
}
|