backend_registry_test.cpp File Reference

#include <algorithm>
#include <atomic>
#include <gtest/gtest.h>
#include <memory>
#include <string>
#include <thread>
#include <vector>
#include "database/core/backend_base.h"
#include "database/core/backend_registry.h"
#include "database/core/database_backend.h"

Include dependency graph for backend_registry_test.cpp:

Go to the source code of this file.

Classes
class	BackendRegistryTest

Functions
	TEST_F (BackendRegistryTest, RegisterBackendSucceeds)
	TEST_F (BackendRegistryTest, RegisterMultipleBackends)
	TEST_F (BackendRegistryTest, DuplicateRegistrationFails)
	TEST_F (BackendRegistryTest, UnregisterExistingBackend)
	TEST_F (BackendRegistryTest, UnregisterNonExistentBackendFails)
	TEST_F (BackendRegistryTest, CreateRegisteredBackend)
	TEST_F (BackendRegistryTest, CreateUnregisteredBackendReturnsNull)
	TEST_F (BackendRegistryTest, CreateReturnsDistinctInstances)
	TEST_F (BackendRegistryTest, CreatedBackendIsNotInitialized)
	TEST_F (BackendRegistryTest, HasBackendReturnsTrueForRegistered)
	TEST_F (BackendRegistryTest, HasBackendReturnsFalseForUnregistered)
	TEST_F (BackendRegistryTest, AvailableBackendsListsAll)
	TEST_F (BackendRegistryTest, BackendCountMatchesRegistrations)
	TEST_F (BackendRegistryTest, EmptyRegistryHasZeroCount)
	TEST_F (BackendRegistryTest, ClearRemovesAllBackends)
	TEST_F (BackendRegistryTest, ReRegisterAfterClear)
	TEST_F (BackendRegistryTest, ConvenienceCreateBackend)
	TEST_F (BackendRegistryTest, ConvenienceHasBackend)
	TEST_F (BackendRegistryTest, ConvenienceAvailableBackends)
	TEST_F (BackendRegistryTest, ConcurrentRegistration)
	TEST_F (BackendRegistryTest, ConcurrentCreation)
	TEST_F (BackendRegistryTest, ConcurrentRegistrationAndQuery)
	TEST_F (BackendRegistryTest, EmptyNameRegistration)
	TEST_F (BackendRegistryTest, RegisterUnregisterRegister)
	TEST_F (BackendRegistryTest, SingletonConsistency)
int	main (int argc, char **argv)

Function Documentation

main()

int main	(	int	argc,
		char **	argv )

Definition at line 461 of file backend_registry_test.cpp.

{
    ::testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}

TEST_F() [1/25]

TEST_F	(	BackendRegistryTest	,
		AvailableBackendsListsAll	)

Definition at line 261 of file backend_registry_test.cpp.

{
    backend_registry::instance().register_backend("alpha", &test_backend::create);
    backend_registry::instance().register_backend("beta", &test_backend_alt::create);
 
    auto backends = backend_registry::instance().available_backends();
    EXPECT_EQ(backends.size(), 2u);
    EXPECT_TRUE(std::find(backends.begin(), backends.end(), "alpha") != backends.end());
    EXPECT_TRUE(std::find(backends.begin(), backends.end(), "beta") != backends.end());
}

References database::core::backend_registry::available_backends(), database::core::backend_registry::instance(), and database::core::backend_registry::register_backend().

Here is the call graph for this function:

TEST_F() [2/25]

TEST_F	(	BackendRegistryTest	,
		BackendCountMatchesRegistrations	)

Definition at line 272 of file backend_registry_test.cpp.

{
    EXPECT_EQ(backend_registry::instance().backend_count(), 0u);
    backend_registry::instance().register_backend("a", &test_backend::create);
    EXPECT_EQ(backend_registry::instance().backend_count(), 1u);
    backend_registry::instance().register_backend("b", &test_backend_alt::create);
    EXPECT_EQ(backend_registry::instance().backend_count(), 2u);
}

References database::core::backend_registry::instance(), and database::core::backend_registry::register_backend().

Here is the call graph for this function:

TEST_F() [3/25]

TEST_F	(	BackendRegistryTest	,
		ClearRemovesAllBackends	)

Definition at line 291 of file backend_registry_test.cpp.

{
    backend_registry::instance().register_backend("a", &test_backend::create);
    backend_registry::instance().register_backend("b", &test_backend_alt::create);
    EXPECT_EQ(backend_registry::instance().backend_count(), 2u);
 
    backend_registry::instance().clear();
    EXPECT_EQ(backend_registry::instance().backend_count(), 0u);
    EXPECT_FALSE(backend_registry::instance().has_backend("a"));
    EXPECT_FALSE(backend_registry::instance().has_backend("b"));
}

References database::core::backend_registry::clear(), database::core::has_backend(), database::core::backend_registry::instance(), and database::core::backend_registry::register_backend().

Here is the call graph for this function:

TEST_F() [4/25]

TEST_F	(	BackendRegistryTest	,
		ConcurrentCreation	)

Definition at line 370 of file backend_registry_test.cpp.

{
    backend_registry::instance().register_backend("test", &test_backend::create);
 
    constexpr int num_threads = 20;
    std::atomic<int> success_count{0};
    std::vector<std::thread> threads;
 
    for (int i = 0; i < num_threads; ++i) {
        threads.emplace_back([&success_count]() {
            auto backend = backend_registry::instance().create("test");
            if (backend != nullptr) {
                success_count++;
            }
        });
    }
 
    for (auto& t : threads) {
        t.join();
    }
 
    EXPECT_EQ(success_count.load(), num_threads);
}

References database::core::backend_registry::create(), database::core::backend_registry::instance(), and database::core::backend_registry::register_backend().

Here is the call graph for this function:

TEST_F() [5/25]

TEST_F	(	BackendRegistryTest	,
		ConcurrentRegistration	)

Definition at line 345 of file backend_registry_test.cpp.

{
    constexpr int num_threads = 10;
    std::atomic<int> success_count{0};
    std::vector<std::thread> threads;
 
    for (int i = 0; i < num_threads; ++i) {
        threads.emplace_back([i, &success_count]() {
            auto result = backend_registry::instance().register_backend(
                "backend_" + std::to_string(i), &test_backend::create);
            if (result.is_ok()) {
                success_count++;
            }
        });
    }
 
    for (auto& t : threads) {
        t.join();
    }
 
    EXPECT_EQ(success_count.load(), num_threads);
    EXPECT_EQ(backend_registry::instance().backend_count(),
              static_cast<size_t>(num_threads));
}

References database::core::backend_registry::instance(), and database::core::backend_registry::register_backend().

Here is the call graph for this function:

TEST_F() [6/25]

TEST_F	(	BackendRegistryTest	,
		ConcurrentRegistrationAndQuery	)

Definition at line 394 of file backend_registry_test.cpp.

{
    constexpr int num_threads = 10;
    std::vector<std::thread> threads;
 
    // Register in parallel
    for (int i = 0; i < num_threads; ++i) {
        threads.emplace_back([i]() {
            backend_registry::instance().register_backend(
                "backend_" + std::to_string(i), &test_backend::create);
        });
    }
 
    // Query in parallel at the same time
    for (int i = 0; i < num_threads; ++i) {
        threads.emplace_back([]() {
            // These may or may not find backends depending on timing
            backend_registry::instance().available_backends();
            backend_registry::instance().backend_count();
        });
    }
 
    for (auto& t : threads) {
        t.join();
    }
 
    // All registrations should eventually succeed
    EXPECT_EQ(backend_registry::instance().backend_count(),
              static_cast<size_t>(num_threads));
}

References database::core::backend_registry::available_backends(), database::core::backend_registry::backend_count(), database::core::backend_registry::instance(), and database::core::backend_registry::register_backend().

Here is the call graph for this function:

TEST_F() [7/25]

TEST_F	(	BackendRegistryTest	,
		ConvenienceAvailableBackends	)

Definition at line 333 of file backend_registry_test.cpp.

{
    backend_registry::instance().register_backend("x", &test_backend::create);
    auto backends = available_backends();
    EXPECT_EQ(backends.size(), 1u);
    EXPECT_EQ(backends[0], "x");
}

References database::core::available_backends(), database::core::backend_registry::instance(), and database::core::backend_registry::register_backend().

Here is the call graph for this function:

TEST_F() [8/25]

TEST_F	(	BackendRegistryTest	,
		ConvenienceCreateBackend	)

Definition at line 318 of file backend_registry_test.cpp.

{
    backend_registry::instance().register_backend("test", &test_backend::create);
    auto backend = create_backend("test");
    ASSERT_NE(backend, nullptr);
    EXPECT_EQ(backend->type(), database_types::sqlite);
}

References database::core::create_backend(), database::core::backend_registry::instance(), and database::core::backend_registry::register_backend().

Here is the call graph for this function:

TEST_F() [9/25]

TEST_F	(	BackendRegistryTest	,
		ConvenienceHasBackend	)

Definition at line 326 of file backend_registry_test.cpp.

{
    backend_registry::instance().register_backend("test", &test_backend::create);
    EXPECT_TRUE(has_backend("test"));
    EXPECT_FALSE(has_backend("nonexistent"));
}

References database::core::has_backend(), database::core::backend_registry::instance(), and database::core::backend_registry::register_backend().

Here is the call graph for this function:

TEST_F() [10/25]

TEST_F	(	BackendRegistryTest	,
		CreatedBackendIsNotInitialized	)

Definition at line 238 of file backend_registry_test.cpp.

{
    backend_registry::instance().register_backend("test", &test_backend::create);
    auto backend = backend_registry::instance().create("test");
    ASSERT_NE(backend, nullptr);
    EXPECT_FALSE(backend->is_initialized());
}

References database::core::backend_registry::create(), database::core::backend_registry::instance(), and database::core::backend_registry::register_backend().

Here is the call graph for this function:

TEST_F() [11/25]

TEST_F	(	BackendRegistryTest	,
		CreateRegisteredBackend	)

Definition at line 214 of file backend_registry_test.cpp.

{
    backend_registry::instance().register_backend("test", &test_backend::create);
    auto backend = backend_registry::instance().create("test");
    ASSERT_NE(backend, nullptr);
    EXPECT_EQ(backend->type(), database_types::sqlite);
}

References database::core::backend_registry::create(), database::core::backend_registry::instance(), and database::core::backend_registry::register_backend().

Here is the call graph for this function:

TEST_F() [12/25]

TEST_F	(	BackendRegistryTest	,
		CreateReturnsDistinctInstances	)

Definition at line 228 of file backend_registry_test.cpp.

{
    backend_registry::instance().register_backend("test", &test_backend::create);
    auto b1 = backend_registry::instance().create("test");
    auto b2 = backend_registry::instance().create("test");
    ASSERT_NE(b1, nullptr);
    ASSERT_NE(b2, nullptr);
    EXPECT_NE(b1.get(), b2.get());
}

References database::core::backend_registry::create(), database::core::backend_registry::instance(), and database::core::backend_registry::register_backend().

Here is the call graph for this function:

TEST_F() [13/25]

TEST_F	(	BackendRegistryTest	,
		CreateUnregisteredBackendReturnsNull	)

Definition at line 222 of file backend_registry_test.cpp.

{
    auto backend = backend_registry::instance().create("nonexistent");
    EXPECT_EQ(backend, nullptr);
}

References database::core::backend_registry::create(), and database::core::backend_registry::instance().

Here is the call graph for this function:

TEST_F() [14/25]

TEST_F	(	BackendRegistryTest	,
		DuplicateRegistrationFails	)

Definition at line 187 of file backend_registry_test.cpp.

{
    EXPECT_TRUE(backend_registry::instance()
        .register_backend("test", &test_backend::create).is_ok());
    auto result = backend_registry::instance()
        .register_backend("test", &test_backend::create);
    EXPECT_FALSE(result.is_ok());
}

References database::core::backend_registry::instance(), and database::core::backend_registry::register_backend().

Here is the call graph for this function:

TEST_F() [15/25]

TEST_F	(	BackendRegistryTest	,
		EmptyNameRegistration	)

Definition at line 429 of file backend_registry_test.cpp.

{
    auto result = backend_registry::instance().register_backend(
        "", &test_backend::create);
    // Empty name should still be valid (implementation-dependent)
    // but we test that it doesn't crash
    if (result.is_ok()) {
        EXPECT_TRUE(backend_registry::instance().has_backend(""));
    }
}

References database::core::has_backend(), database::core::backend_registry::instance(), and database::core::backend_registry::register_backend().

Here is the call graph for this function:

TEST_F() [16/25]

TEST_F	(	BackendRegistryTest	,
		EmptyRegistryHasZeroCount	)

Definition at line 281 of file backend_registry_test.cpp.

{
    EXPECT_EQ(backend_registry::instance().backend_count(), 0u);
    EXPECT_TRUE(backend_registry::instance().available_backends().empty());
}

References database::core::available_backends(), and database::core::backend_registry::instance().

Here is the call graph for this function:

TEST_F() [17/25]

TEST_F	(	BackendRegistryTest	,
		HasBackendReturnsFalseForUnregistered	)

Definition at line 256 of file backend_registry_test.cpp.

{
    EXPECT_FALSE(backend_registry::instance().has_backend("nonexistent"));
}

References database::core::has_backend(), and database::core::backend_registry::instance().

Here is the call graph for this function:

TEST_F() [18/25]

TEST_F	(	BackendRegistryTest	,
		HasBackendReturnsTrueForRegistered	)

Definition at line 250 of file backend_registry_test.cpp.

{
    backend_registry::instance().register_backend("test", &test_backend::create);
    EXPECT_TRUE(backend_registry::instance().has_backend("test"));
}

References database::core::has_backend(), database::core::backend_registry::instance(), and database::core::backend_registry::register_backend().

Here is the call graph for this function:

TEST_F() [19/25]

TEST_F	(	BackendRegistryTest	,
		RegisterBackendSucceeds	)

Definition at line 171 of file backend_registry_test.cpp.

{
    auto result = backend_registry::instance().register_backend(
        "test", &test_backend::create);
    EXPECT_TRUE(result.is_ok());
}

References database::core::backend_registry::instance(), and database::core::backend_registry::register_backend().

Here is the call graph for this function:

TEST_F() [20/25]

TEST_F	(	BackendRegistryTest	,
		RegisterMultipleBackends	)

Definition at line 178 of file backend_registry_test.cpp.

{
    EXPECT_TRUE(backend_registry::instance()
        .register_backend("test1", &test_backend::create).is_ok());
    EXPECT_TRUE(backend_registry::instance()
        .register_backend("test2", &test_backend_alt::create).is_ok());
    EXPECT_EQ(backend_registry::instance().backend_count(), 2u);
}

References database::core::backend_registry::instance().

Here is the call graph for this function:

TEST_F() [21/25]

TEST_F	(	BackendRegistryTest	,
		RegisterUnregisterRegister	)

Definition at line 440 of file backend_registry_test.cpp.

{
    backend_registry::instance().register_backend("test", &test_backend::create);
    backend_registry::instance().unregister_backend("test");
    auto result = backend_registry::instance().register_backend(
        "test", &test_backend_alt::create);
    EXPECT_TRUE(result.is_ok());
 
    auto backend = backend_registry::instance().create("test");
    ASSERT_NE(backend, nullptr);
    // After re-registration with alt type, should return postgres type
    EXPECT_EQ(backend->type(), database_types::postgres);
}

References database::core::backend_registry::create(), database::core::backend_registry::instance(), database::core::backend_registry::register_backend(), and database::core::backend_registry::unregister_backend().

Here is the call graph for this function:

TEST_F() [22/25]

TEST_F	(	BackendRegistryTest	,
		ReRegisterAfterClear	)

Definition at line 303 of file backend_registry_test.cpp.

{
    backend_registry::instance().register_backend("test", &test_backend::create);
    backend_registry::instance().clear();
 
    auto result = backend_registry::instance().register_backend(
        "test", &test_backend::create);
    EXPECT_TRUE(result.is_ok());
    EXPECT_TRUE(backend_registry::instance().has_backend("test"));
}

References database::core::backend_registry::clear(), database::core::has_backend(), database::core::backend_registry::instance(), and database::core::backend_registry::register_backend().

Here is the call graph for this function:

TEST_F() [23/25]

TEST_F	(	BackendRegistryTest	,
		SingletonConsistency	)

Definition at line 454 of file backend_registry_test.cpp.

{
    auto& instance1 = backend_registry::instance();
    auto& instance2 = backend_registry::instance();
    EXPECT_EQ(&instance1, &instance2);
}

References database::core::backend_registry::instance().

Here is the call graph for this function:

TEST_F() [24/25]

TEST_F	(	BackendRegistryTest	,
		UnregisterExistingBackend	)

Definition at line 196 of file backend_registry_test.cpp.

{
    backend_registry::instance().register_backend("test", &test_backend::create);
    auto result = backend_registry::instance().unregister_backend("test");
    EXPECT_TRUE(result.is_ok());
    EXPECT_FALSE(backend_registry::instance().has_backend("test"));
}

References database::core::has_backend(), database::core::backend_registry::instance(), database::core::backend_registry::register_backend(), and database::core::backend_registry::unregister_backend().

Here is the call graph for this function:

TEST_F() [25/25]

TEST_F	(	BackendRegistryTest	,
		UnregisterNonExistentBackendFails	)

Definition at line 204 of file backend_registry_test.cpp.

{
    auto result = backend_registry::instance().unregister_backend("nonexistent");
    EXPECT_FALSE(result.is_ok());
}

References database::core::backend_registry::instance(), and database::core::backend_registry::unregister_backend().

Here is the call graph for this function: