test_di_container.cpp File Reference

Unit tests for monitoring_system DI container integration. More...

#include <gtest/gtest.h>
#include <kcenon/common/di/service_container.h>
#include <atomic>
#include <chrono>
#include <memory>
#include <stdexcept>
#include <string>
#include <thread>
#include <vector>

Include dependency graph for test_di_container.cpp:

Go to the source code of this file.

Classes
class	IService
class	ServiceA
class	ServiceB
class	DIContainerTest

Functions
	TEST_F (DIContainerTest, RegisterAndResolveTransient)
	TEST_F (DIContainerTest, RegisterAndResolveSingleton)
	TEST_F (DIContainerTest, RegisterSingletonInstance)
	TEST_F (DIContainerTest, ServiceWithDependencies)
	TEST_F (DIContainerTest, ScopedContainer)
	TEST_F (DIContainerTest, ResolveUnregisteredService)
	TEST_F (DIContainerTest, ResolveOrNullUnregistered)
	TEST_F (DIContainerTest, ClearContainer)
	TEST_F (DIContainerTest, UnregisterService)
	TEST_F (DIContainerTest, DuplicateRegistrationFails)
	TEST_F (DIContainerTest, ThreadSafety)
	TEST_F (DIContainerTest, RegisteredServicesDescriptors)
	TEST_F (DIContainerTest, FreezePreventsRegistration)
	TEST_F (DIContainerTest, FreezeAllowsResolution)

Detailed Description

Unit tests for monitoring_system DI container integration.

Tests validate that monitoring_system types work correctly with common_system's service_container, covering registration, resolution, lifetime management, dependency injection, scoping, and thread safety.

Part of kcenon/common_system#368

Definition in file test_di_container.cpp.

Function Documentation

TEST_F() [1/14]

TEST_F	(	DIContainerTest	,
		ClearContainer	)

Test clear functionality

Definition at line 247 of file test_di_container.cpp.

{
    container_.register_simple_factory<IService>(
        []() { return std::make_shared<ServiceA>(); }, service_lifetime::singleton);
 
    EXPECT_TRUE(container_.is_registered<IService>());
 
    container_.clear();
 
    EXPECT_FALSE(container_.is_registered<IService>());
 
    auto resolve_result = container_.resolve<IService>();
    EXPECT_TRUE(resolve_result.is_err());
}

TEST_F() [2/14]

TEST_F	(	DIContainerTest	,
		DuplicateRegistrationFails	)

Test duplicate registration fails

Definition at line 280 of file test_di_container.cpp.

{
    auto result1 = container_.register_simple_factory<IService>(
        []() { return std::make_shared<ServiceA>(); }, service_lifetime::singleton);
    ASSERT_TRUE(result1.is_ok());
 
    auto result2 = container_.register_simple_factory<IService>(
        []() { return std::make_shared<ServiceA>(); }, service_lifetime::singleton);
    EXPECT_TRUE(result2.is_err());
}

TEST_F() [3/14]

TEST_F	(	DIContainerTest	,
		FreezeAllowsResolution	)

Test freeze still allows resolution

Definition at line 370 of file test_di_container.cpp.

{
    container_.register_simple_factory<IService>(
        []() { return std::make_shared<ServiceA>(); }, service_lifetime::singleton);
 
    container_.freeze();
 
    auto result = container_.resolve<IService>();
    EXPECT_TRUE(result.is_ok());
    EXPECT_NE(result.value(), nullptr);
}

TEST_F() [4/14]

TEST_F	(	DIContainerTest	,
		FreezePreventsRegistration	)

Test freeze prevents new registrations

Definition at line 353 of file test_di_container.cpp.

{
    container_.register_simple_factory<IService>(
        []() { return std::make_shared<ServiceA>(); }, service_lifetime::singleton);
 
    container_.freeze();
    EXPECT_TRUE(container_.is_frozen());
 
    auto result = container_.register_simple_factory<ServiceA>(
        []() { return std::make_shared<ServiceA>(); }, service_lifetime::transient);
 
    EXPECT_TRUE(result.is_err());
}

TEST_F() [5/14]

TEST_F	(	DIContainerTest	,
		RegisterAndResolveSingleton	)

Test singleton lifetime

Definition at line 125 of file test_di_container.cpp.

{
    auto result = container_.register_simple_factory<IService>(
        []() { return std::make_shared<ServiceA>(); }, service_lifetime::singleton);
 
    ASSERT_TRUE(result.is_ok());
 
    // Resolve multiple times
    auto service1_result = container_.resolve<IService>();
    auto service2_result = container_.resolve<IService>();
 
    ASSERT_TRUE(service1_result.is_ok());
    ASSERT_TRUE(service2_result.is_ok());
 
    auto service1 = service1_result.value();
    auto service2 = service2_result.value();
 
    // Singleton services should be the same instance
    EXPECT_EQ(service1, service2);
    EXPECT_EQ(ServiceA::get_instance_count(), 1);
    EXPECT_EQ(service1->get_name(), "ServiceA_1");
    EXPECT_EQ(service2->get_name(), "ServiceA_1");
}

References ServiceA::get_instance_count().

Here is the call graph for this function:

TEST_F() [6/14]

TEST_F	(	DIContainerTest	,
		RegisterAndResolveTransient	)

Test basic service registration and resolution with transient lifetime

Definition at line 96 of file test_di_container.cpp.

{
    auto result = container_.register_simple_factory<IService>(
        []() { return std::make_shared<ServiceA>(); }, service_lifetime::transient);
 
    ASSERT_TRUE(result.is_ok());
    EXPECT_TRUE(container_.is_registered<IService>());
 
    // Resolve service multiple times
    auto service1_result = container_.resolve<IService>();
    ASSERT_TRUE(service1_result.is_ok());
    auto service1 = service1_result.value();
    EXPECT_NE(service1, nullptr);
    EXPECT_EQ(service1->get_name(), "ServiceA_1");
 
    auto service2_result = container_.resolve<IService>();
    ASSERT_TRUE(service2_result.is_ok());
    auto service2 = service2_result.value();
    EXPECT_NE(service2, nullptr);
    EXPECT_EQ(service2->get_name(), "ServiceA_2");
 
    // Transient services should be different instances
    EXPECT_NE(service1, service2);
    EXPECT_EQ(ServiceA::get_instance_count(), 2);
}

References ServiceA::get_instance_count().

Here is the call graph for this function:

TEST_F() [7/14]

TEST_F	(	DIContainerTest	,
		RegisteredServicesDescriptors	)

Test registered_services returns descriptors

Definition at line 338 of file test_di_container.cpp.

{
    container_.register_simple_factory<IService>(
        []() { return std::make_shared<ServiceA>(); }, service_lifetime::singleton);
 
    container_.register_simple_factory<ServiceA>(
        []() { return std::make_shared<ServiceA>(); }, service_lifetime::transient);
 
    auto services = container_.registered_services();
    EXPECT_GE(services.size(), 2u);
}

TEST_F() [8/14]

TEST_F	(	DIContainerTest	,
		RegisterSingletonInstance	)

Test direct instance registration

Definition at line 152 of file test_di_container.cpp.

{
    auto instance = std::make_shared<ServiceA>();
    auto initial_name = instance->get_name();
 
    auto result = container_.register_instance<IService>(instance);
    ASSERT_TRUE(result.is_ok());
 
    // Resolve should return the same instance
    auto resolved_result = container_.resolve<IService>();
    ASSERT_TRUE(resolved_result.is_ok());
    auto resolved = resolved_result.value();
 
    EXPECT_EQ(resolved, instance);
    EXPECT_EQ(resolved->get_name(), initial_name);
}

TEST_F() [9/14]

TEST_F	(	DIContainerTest	,
		ResolveOrNullUnregistered	)

Test resolve_or_null for unregistered service returns nullptr

Definition at line 238 of file test_di_container.cpp.

{
    auto ptr = container_.resolve_or_null<IService>();
    EXPECT_EQ(ptr, nullptr);
}

TEST_F() [10/14]

TEST_F	(	DIContainerTest	,
		ResolveUnregisteredService	)

Test error handling - resolve unregistered service

Definition at line 229 of file test_di_container.cpp.

{
    auto result = container_.resolve<IService>();
    EXPECT_TRUE(result.is_err());
}

TEST_F() [11/14]

TEST_F	(	DIContainerTest	,
		ScopedContainer	)

Test scoped container

Definition at line 207 of file test_di_container.cpp.

{
    // Register singleton in root container
    container_.register_simple_factory<IService>(
        []() { return std::make_shared<ServiceA>(); }, service_lifetime::singleton);
 
    // Create scoped container
    auto scope = container_.create_scope();
    ASSERT_NE(scope, nullptr);
 
    // Scoped container should inherit parent registrations
    EXPECT_TRUE(scope->is_registered<IService>());
 
    // Resolve in scope should work
    auto service_result = scope->resolve<IService>();
    ASSERT_TRUE(service_result.is_ok());
    EXPECT_NE(service_result.value(), nullptr);
}

TEST_F() [12/14]

TEST_F	(	DIContainerTest	,
		ServiceWithDependencies	)

Test service with dependencies resolved through the container

Definition at line 172 of file test_di_container.cpp.

{
    // Register dependency as singleton
    container_.register_simple_factory<ServiceA>(
        []() { return std::make_shared<ServiceA>(); }, service_lifetime::singleton);
 
    // Register service that depends on ServiceA, using container to resolve
    container_.register_factory<ServiceB>(
        [](IServiceContainer& c) {
            auto dep_result = c.resolve<ServiceA>();
            if (dep_result.is_err()) {
                throw std::runtime_error("Failed to resolve dependency");
            }
            return std::make_shared<ServiceB>(dep_result.value());
        },
        service_lifetime::transient);
 
    // Resolve service with dependencies
    auto service_result = container_.resolve<ServiceB>();
    ASSERT_TRUE(service_result.is_ok());
    auto service = service_result.value();
 
    EXPECT_NE(service, nullptr);
    auto dependency = service->get_dependency();
    EXPECT_NE(dependency, nullptr);
 
    // Dependency should be the same singleton
    auto dep_result = container_.resolve<ServiceA>();
    ASSERT_TRUE(dep_result.is_ok());
    EXPECT_EQ(dependency, dep_result.value());
}

TEST_F() [13/14]

TEST_F	(	DIContainerTest	,
		ThreadSafety	)

Test thread safety of singleton resolution

Definition at line 294 of file test_di_container.cpp.

{
    container_.register_simple_factory<IService>(
        []() {
            std::this_thread::sleep_for(std::chrono::milliseconds(1));
            return std::make_shared<ServiceA>();
        },
        service_lifetime::singleton);
 
    // Resolve from multiple threads
    const int num_threads = 10;
    std::vector<std::thread> threads;
    std::vector<std::shared_ptr<IService>> results(num_threads);
 
    for (int i = 0; i < num_threads; ++i) {
        threads.emplace_back(
            [this, &results, i]()
            {
                auto result = container_.resolve<IService>();
                if (result.is_ok()) {
                    results[i] = result.value();
                }
            });
    }
 
    for (auto& t : threads) {
        t.join();
    }
 
    // All threads should get the same singleton instance
    auto first = results[0];
    EXPECT_NE(first, nullptr);
 
    for (const auto& result : results) {
        EXPECT_EQ(result, first);
    }
 
    // Only one instance should have been created
    EXPECT_EQ(ServiceA::get_instance_count(), 1);
}

References ServiceA::get_instance_count().

Here is the call graph for this function:

TEST_F() [14/14]

TEST_F	(	DIContainerTest	,
		UnregisterService	)

Test unregister specific service

Definition at line 265 of file test_di_container.cpp.

{
    container_.register_simple_factory<IService>(
        []() { return std::make_shared<ServiceA>(); }, service_lifetime::singleton);
 
    EXPECT_TRUE(container_.is_registered<IService>());
 
    auto result = container_.unregister<IService>();
    EXPECT_TRUE(result.is_ok());
    EXPECT_FALSE(container_.is_registered<IService>());
}