test_storage_backends.cpp File Reference

#include <gtest/gtest.h>
#include <kcenon/monitoring/storage/storage_backends.h>
#include <kcenon/monitoring/interfaces/monitoring_core.h>
#include <filesystem>
#include <fstream>
#include <thread>
#include <atomic>

Include dependency graph for test_storage_backends.cpp:

Go to the source code of this file.

Classes
class	StorageBackendsTest

Functions
	TEST_F (StorageBackendsTest, StorageConfigValidation)
	TEST_F (StorageBackendsTest, FileStorageBackendBasicOperations)
	TEST_F (StorageBackendsTest, FileStorageBackendCapacityLimit)
	TEST_F (StorageBackendsTest, FileStorageBackendDifferentFormats)
	TEST_F (StorageBackendsTest, MemoryStorageBackend)
	TEST_F (StorageBackendsTest, DatabaseStorageBackendBasicOperations)
	TEST_F (StorageBackendsTest, DatabaseStorageBackendDifferentTypes)
	TEST_F (StorageBackendsTest, CloudStorageBackendBasicOperations)
	TEST_F (StorageBackendsTest, CloudStorageBackendDifferentProviders)
	TEST_F (StorageBackendsTest, StorageBackendFactory)
	TEST_F (StorageBackendsTest, SupportedBackendsList)
	TEST_F (StorageBackendsTest, HelperFunctions)
	TEST_F (StorageBackendsTest, ErrorHandling)
	TEST_F (StorageBackendsTest, ConcurrentOperations)
	TEST_F (StorageBackendsTest, LargeDatasetHandling)

Function Documentation

TEST_F() [1/15]

TEST_F	(	StorageBackendsTest	,
		CloudStorageBackendBasicOperations	)

Definition at line 354 of file test_storage_backends.cpp.

                                                                {
    storage_config config;
    config.type = storage_backend_type::cloud_s3;
    config.path = "test-monitoring-bucket";
    config.max_capacity = 1000;
    
    cloud_storage_backend backend(config);
    
    // Test initial state
    EXPECT_EQ(backend.capacity(), 1000);
    EXPECT_EQ(backend.size(), 0);
    
    // Store snapshots
    for (const auto& snapshot : test_snapshots_) {
        auto store_result = backend.store(snapshot);
        EXPECT_TRUE(store_result.is_ok());
    }
    
    EXPECT_EQ(backend.size(), 3);
    
    // Retrieve snapshot
    auto retrieve_result = backend.retrieve(0);
    EXPECT_TRUE(retrieve_result.is_ok());
    
    // Retrieve range
    auto range_result = backend.retrieve_range(0, 2);
    EXPECT_TRUE(range_result.is_ok());
    EXPECT_LE(range_result.value().size(), 2); // May be less due to simulated failures
    
    // Test flush
    auto flush_result = backend.flush();
    EXPECT_TRUE(flush_result.is_ok());
    
    // Test clear
    auto clear_result = backend.clear();
    EXPECT_TRUE(clear_result.is_ok());
    EXPECT_EQ(backend.size(), 0);
}

References kcenon::monitoring::cloud_storage_backend::capacity(), kcenon::monitoring::cloud_storage_backend::clear(), kcenon::monitoring::cloud_storage_backend::flush(), kcenon::monitoring::storage_config::max_capacity, kcenon::monitoring::storage_config::path, kcenon::monitoring::cloud_storage_backend::retrieve(), kcenon::monitoring::cloud_storage_backend::retrieve_range(), kcenon::monitoring::cloud_storage_backend::size(), kcenon::monitoring::cloud_storage_backend::store(), and kcenon::monitoring::storage_config::type.

Here is the call graph for this function:

TEST_F() [2/15]

TEST_F	(	StorageBackendsTest	,
		CloudStorageBackendDifferentProviders	)

Definition at line 393 of file test_storage_backends.cpp.

                                                                   {
    // Test AWS S3
    {
        storage_config s3_config;
        s3_config.type = storage_backend_type::cloud_s3;
        s3_config.path = "s3-test-bucket";
        s3_config.max_capacity = 100;
        
        cloud_storage_backend s3_backend(s3_config);
        auto store_result = s3_backend.store(test_snapshots_[0]);
        EXPECT_TRUE(store_result.is_ok());
    }
    
    // Test Google Cloud Storage
    {
        storage_config gcs_config;
        gcs_config.type = storage_backend_type::cloud_gcs;
        gcs_config.path = "gcs-test-bucket";
        gcs_config.max_capacity = 100;
        
        cloud_storage_backend gcs_backend(gcs_config);
        auto store_result = gcs_backend.store(test_snapshots_[0]);
        EXPECT_TRUE(store_result.is_ok());
    }
    
    // Test Azure Blob Storage
    {
        storage_config azure_config;
        azure_config.type = storage_backend_type::cloud_azure_blob;
        azure_config.path = "azure-test-container";
        azure_config.max_capacity = 100;
        
        cloud_storage_backend azure_backend(azure_config);
        auto store_result = azure_backend.store(test_snapshots_[0]);
        EXPECT_TRUE(store_result.is_ok());
    }
}

References kcenon::monitoring::storage_config::max_capacity, kcenon::monitoring::storage_config::path, kcenon::monitoring::cloud_storage_backend::store(), and kcenon::monitoring::storage_config::type.

Here is the call graph for this function:

TEST_F() [3/15]

TEST_F	(	StorageBackendsTest	,
		ConcurrentOperations	)

Definition at line 570 of file test_storage_backends.cpp.

                                                  {
    storage_config config;
    config.type = storage_backend_type::memory_buffer;
    config.max_capacity = 100;
    
    file_storage_backend backend(config);
    
    // Test concurrent stores
    std::vector<std::thread> store_threads;
    std::atomic<int> successful_stores{0};
    
    for (int i = 0; i < 10; ++i) {
        store_threads.emplace_back([&, i]() {
            metrics_snapshot snapshot;
            snapshot.source_id = "thread_" + std::to_string(i);
            snapshot.add_metric("value", static_cast<double>(i));
            
            auto result = backend.store(snapshot);
            if (result.is_ok()) {
                successful_stores++;
            }
        });
    }
    
    for (auto& thread : store_threads) {
        thread.join();
    }
    
    EXPECT_EQ(successful_stores.load(), 10);
    EXPECT_EQ(backend.size(), 10);
    
    // Test concurrent retrieval
    std::vector<std::thread> retrieve_threads;
    std::atomic<int> successful_retrievals{0};
    
    for (int i = 0; i < 5; ++i) {
        retrieve_threads.emplace_back([&, i]() {
            auto result = backend.retrieve(i);
            if (result.is_ok()) {
                successful_retrievals++;
            }
        });
    }
    
    for (auto& thread : retrieve_threads) {
        thread.join();
    }
    
    EXPECT_EQ(successful_retrievals.load(), 5);
}

References kcenon::monitoring::metrics_snapshot::add_metric(), kcenon::monitoring::storage_config::max_capacity, kcenon::monitoring::file_storage_backend::retrieve(), kcenon::monitoring::file_storage_backend::size(), kcenon::monitoring::metrics_snapshot::source_id, kcenon::monitoring::file_storage_backend::store(), and kcenon::monitoring::storage_config::type.

Here is the call graph for this function:

TEST_F() [4/15]

TEST_F	(	StorageBackendsTest	,
		DatabaseStorageBackendBasicOperations	)

Definition at line 263 of file test_storage_backends.cpp.

                                                                   {
    storage_config config;
    config.type = storage_backend_type::database_sqlite;
    config.path = (test_dir_ / "test.db").string();
    config.table_name = "test_metrics";
    config.max_capacity = 100;
    
    database_storage_backend backend(config);
    
    // Test initial state
    EXPECT_EQ(backend.capacity(), 100);
    EXPECT_GE(backend.size(), 0); // Database starts at 0
    
    // Store snapshots
    for (const auto& snapshot : test_snapshots_) {
        auto store_result = backend.store(snapshot);
        EXPECT_TRUE(store_result.is_ok());
    }
    
    EXPECT_EQ(backend.size(), 3);
    
    // Retrieve snapshot
    auto retrieve_result = backend.retrieve(0);
    EXPECT_TRUE(retrieve_result.is_ok());
    
    // Retrieve range
    auto range_result = backend.retrieve_range(0, 2);
    EXPECT_TRUE(range_result.is_ok());
    
    // Test flush
    auto flush_result = backend.flush();
    EXPECT_TRUE(flush_result.is_ok());
    
    // Test clear
    auto clear_result = backend.clear();
    EXPECT_TRUE(clear_result.is_ok());
    EXPECT_EQ(backend.size(), 0);
    
    // Get statistics
    auto stats = backend.get_stats();
    EXPECT_EQ(stats["stored_count"], 0); // After clear
    EXPECT_EQ(stats["capacity"], 100);
    EXPECT_EQ(stats["connected"], 1);
}

References kcenon::monitoring::database_storage_backend::capacity(), kcenon::monitoring::database_storage_backend::clear(), kcenon::monitoring::database_storage_backend::flush(), kcenon::monitoring::database_storage_backend::get_stats(), kcenon::monitoring::storage_config::max_capacity, kcenon::monitoring::storage_config::path, kcenon::monitoring::database_storage_backend::retrieve(), kcenon::monitoring::database_storage_backend::retrieve_range(), kcenon::monitoring::database_storage_backend::size(), kcenon::monitoring::database_storage_backend::store(), kcenon::monitoring::storage_config::table_name, and kcenon::monitoring::storage_config::type.

Here is the call graph for this function:

TEST_F() [5/15]

TEST_F	(	StorageBackendsTest	,
		DatabaseStorageBackendDifferentTypes	)

Definition at line 308 of file test_storage_backends.cpp.

                                                                  {
    // Test SQLite
    {
        storage_config sqlite_config;
        sqlite_config.type = storage_backend_type::database_sqlite;
        sqlite_config.path = (test_dir_ / "sqlite.db").string();
        sqlite_config.max_capacity = 50;
        
        database_storage_backend sqlite_backend(sqlite_config);
        auto store_result = sqlite_backend.store(test_snapshots_[0]);
        EXPECT_TRUE(store_result.is_ok());
    }
    
    // Test PostgreSQL (simulated)
    {
        storage_config pg_config;
        pg_config.type = storage_backend_type::database_postgresql;
        pg_config.host = "localhost";
        pg_config.port = 5432;
        pg_config.database_name = "monitoring_test";
        pg_config.username = "test_user";
        pg_config.password = "test_pass";
        pg_config.max_capacity = 50;
        
        database_storage_backend pg_backend(pg_config);
        auto store_result = pg_backend.store(test_snapshots_[0]);
        EXPECT_TRUE(store_result.is_ok());
    }
    
    // Test MySQL (simulated)
    {
        storage_config mysql_config;
        mysql_config.type = storage_backend_type::database_mysql;
        mysql_config.host = "localhost";
        mysql_config.port = 3306;
        mysql_config.database_name = "monitoring_test";
        mysql_config.username = "test_user";
        mysql_config.password = "test_pass";
        mysql_config.max_capacity = 50;
        
        database_storage_backend mysql_backend(mysql_config);
        auto store_result = mysql_backend.store(test_snapshots_[0]);
        EXPECT_TRUE(store_result.is_ok());
    }
}

References kcenon::monitoring::storage_config::database_name, kcenon::monitoring::storage_config::host, kcenon::monitoring::storage_config::max_capacity, kcenon::monitoring::storage_config::password, kcenon::monitoring::storage_config::path, kcenon::monitoring::storage_config::port, kcenon::monitoring::database_storage_backend::store(), kcenon::monitoring::storage_config::type, and kcenon::monitoring::storage_config::username.

Here is the call graph for this function:

TEST_F() [6/15]

TEST_F	(	StorageBackendsTest	,
		ErrorHandling	)

Definition at line 535 of file test_storage_backends.cpp.

                                           {
    // Test file storage with invalid path (skip if filesystem throws)
    {
        try {
            storage_config invalid_config;
            invalid_config.type = storage_backend_type::file_json;
            invalid_config.path = "/invalid/path/that/does/not/exist/file.json";
            invalid_config.max_capacity = 10;
            
            // Constructor may throw if filesystem operations fail
            file_storage_backend backend(invalid_config);
            
            // Store operation may fail due to invalid path
            auto store_result = backend.store(test_snapshots_[0]);
            // Don't assert on result as it depends on filesystem permissions
        } catch (const std::exception&) {
            // Expected if filesystem doesn't allow directory creation
            // This is acceptable for this test
        }
    }
    
    // Test retrieval of non-existent snapshot
    {
        storage_config config;
        config.type = storage_backend_type::memory_buffer;
        config.max_capacity = 10;
        
        file_storage_backend backend(config);
        
        auto retrieve_result = backend.retrieve(999);
        EXPECT_FALSE(retrieve_result.is_ok());
        EXPECT_EQ(retrieve_result.error().code, static_cast<int>(monitoring_error_code::not_found));
    }
}

References kcenon::monitoring::storage_config::max_capacity, kcenon::monitoring::storage_config::path, kcenon::monitoring::file_storage_backend::retrieve(), kcenon::monitoring::file_storage_backend::store(), and kcenon::monitoring::storage_config::type.

Here is the call graph for this function:

TEST_F() [7/15]

TEST_F	(	StorageBackendsTest	,
		FileStorageBackendBasicOperations	)

Definition at line 124 of file test_storage_backends.cpp.

                                                               {
    storage_config config;
    config.type = storage_backend_type::file_json;
    config.path = (test_dir_ / "test.json").string();
    config.max_capacity = 10;
    
    file_storage_backend backend(config);
    
    // Test initial state
    EXPECT_EQ(backend.size(), 0);
    EXPECT_EQ(backend.capacity(), 10);
    
    // Store snapshots
    for (const auto& snapshot : test_snapshots_) {
        auto store_result = backend.store(snapshot);
        EXPECT_TRUE(store_result.is_ok());
    }
    
    EXPECT_EQ(backend.size(), 3);
    
    // Retrieve snapshot
    auto retrieve_result = backend.retrieve(0);
    EXPECT_TRUE(retrieve_result.is_ok());
    
    // Retrieve range
    auto range_result = backend.retrieve_range(0, 2);
    EXPECT_TRUE(range_result.is_ok());
    EXPECT_EQ(range_result.value().size(), 2);
    
    // Test flush
    auto flush_result = backend.flush();
    EXPECT_TRUE(flush_result.is_ok());
    
    // Test clear
    auto clear_result = backend.clear();
    EXPECT_TRUE(clear_result.is_ok());
    EXPECT_EQ(backend.size(), 0);
}

References kcenon::monitoring::file_storage_backend::capacity(), kcenon::monitoring::file_storage_backend::clear(), kcenon::monitoring::file_storage_backend::flush(), kcenon::monitoring::storage_config::max_capacity, kcenon::monitoring::storage_config::path, kcenon::monitoring::file_storage_backend::retrieve(), kcenon::monitoring::file_storage_backend::retrieve_range(), kcenon::monitoring::file_storage_backend::size(), kcenon::monitoring::file_storage_backend::store(), and kcenon::monitoring::storage_config::type.

Here is the call graph for this function:

TEST_F() [8/15]

TEST_F	(	StorageBackendsTest	,
		FileStorageBackendCapacityLimit	)

Definition at line 163 of file test_storage_backends.cpp.

                                                             {
    storage_config config;
    config.type = storage_backend_type::file_json;
    config.path = (test_dir_ / "capacity_test.json").string();
    config.max_capacity = 2; // Small capacity for testing
    
    file_storage_backend backend(config);
    
    // Store snapshots beyond capacity
    for (const auto& snapshot : test_snapshots_) {
        auto store_result = backend.store(snapshot);
        EXPECT_TRUE(store_result.is_ok());
    }
    
    // Should not exceed capacity (oldest removed)
    EXPECT_EQ(backend.size(), 2);
    
    // Get statistics
    auto stats = backend.get_stats();
    EXPECT_EQ(stats["total_snapshots"], 2);
    EXPECT_EQ(stats["capacity"], 2);
}

References kcenon::monitoring::file_storage_backend::get_stats(), kcenon::monitoring::storage_config::max_capacity, kcenon::monitoring::storage_config::path, kcenon::monitoring::file_storage_backend::size(), kcenon::monitoring::file_storage_backend::store(), and kcenon::monitoring::storage_config::type.

Here is the call graph for this function:

TEST_F() [9/15]

TEST_F	(	StorageBackendsTest	,
		FileStorageBackendDifferentFormats	)

Definition at line 186 of file test_storage_backends.cpp.

                                                                {
    // Test JSON format
    {
        storage_config json_config;
        json_config.type = storage_backend_type::file_json;
        json_config.path = (test_dir_ / "test.json").string();
        json_config.max_capacity = 10;
        
        file_storage_backend json_backend(json_config);
        auto store_result = json_backend.store(test_snapshots_[0]);
        EXPECT_TRUE(store_result.is_ok());
        
        auto retrieve_result = json_backend.retrieve(0);
        EXPECT_TRUE(retrieve_result.is_ok());
    }
    
    // Test Binary format
    {
        storage_config binary_config;
        binary_config.type = storage_backend_type::file_binary;
        binary_config.path = (test_dir_ / "test.bin").string();
        binary_config.max_capacity = 10;
        
        file_storage_backend binary_backend(binary_config);
        auto store_result = binary_backend.store(test_snapshots_[0]);
        EXPECT_TRUE(store_result.is_ok());
        
        auto retrieve_result = binary_backend.retrieve(0);
        EXPECT_TRUE(retrieve_result.is_ok());
    }
    
    // Test CSV format
    {
        storage_config csv_config;
        csv_config.type = storage_backend_type::file_csv;
        csv_config.path = (test_dir_ / "test.csv").string();
        csv_config.max_capacity = 10;
        
        file_storage_backend csv_backend(csv_config);
        auto store_result = csv_backend.store(test_snapshots_[0]);
        EXPECT_TRUE(store_result.is_ok());
        
        auto retrieve_result = csv_backend.retrieve(0);
        EXPECT_TRUE(retrieve_result.is_ok());
    }
}

References kcenon::monitoring::storage_config::max_capacity, kcenon::monitoring::storage_config::path, kcenon::monitoring::file_storage_backend::retrieve(), kcenon::monitoring::file_storage_backend::store(), and kcenon::monitoring::storage_config::type.

Here is the call graph for this function:

TEST_F() [10/15]

TEST_F	(	StorageBackendsTest	,
		HelperFunctions	)

Definition at line 498 of file test_storage_backends.cpp.

                                             {
    // Test file storage helper
    {
        auto backend = create_file_storage(
            (test_dir_ / "helper_test.json").string(),
            storage_backend_type::file_json,
            100);
        EXPECT_TRUE(backend);
        
        auto store_result = backend->store(test_snapshots_[0]);
        EXPECT_TRUE(store_result.is_ok());
    }
    
    // Test database storage helper
    {
        auto backend = create_database_storage(
            storage_backend_type::database_sqlite,
            (test_dir_ / "helper_test.db").string(),
            "test_table");
        EXPECT_TRUE(backend);
        
        auto store_result = backend->store(test_snapshots_[0]);
        EXPECT_TRUE(store_result.is_ok());
    }
    
    // Test cloud storage helper
    {
        auto backend = create_cloud_storage(
            storage_backend_type::cloud_s3,
            "helper-test-bucket");
        EXPECT_TRUE(backend);
        
        auto store_result = backend->store(test_snapshots_[0]);
        EXPECT_TRUE(store_result.is_ok());
    }
}

References kcenon::monitoring::create_cloud_storage(), kcenon::monitoring::create_database_storage(), and kcenon::monitoring::create_file_storage().

Here is the call graph for this function:

TEST_F() [11/15]

TEST_F	(	StorageBackendsTest	,
		LargeDatasetHandling	)

Definition at line 621 of file test_storage_backends.cpp.

                                                  {
    storage_config config;
    config.type = storage_backend_type::memory_buffer;
    config.max_capacity = 50;
    
    file_storage_backend backend(config);
    
    // Store more data than capacity
    for (int i = 0; i < 100; ++i) {
        metrics_snapshot snapshot;
        snapshot.source_id = "generator_" + std::to_string(i);
        
        // Add multiple metrics per snapshot
        for (int j = 0; j < 10; ++j) {
            snapshot.add_metric("metric_" + std::to_string(j), static_cast<double>(i * 10 + j));
        }
        
        auto store_result = backend.store(snapshot);
        EXPECT_TRUE(store_result.is_ok());
    }
    
    // Should not exceed capacity
    EXPECT_EQ(backend.size(), 50);
    
    // Test range retrieval of large dataset
    auto range_result = backend.retrieve_range(0, 25);
    EXPECT_TRUE(range_result.is_ok());
    EXPECT_EQ(range_result.value().size(), 25);
}

References kcenon::monitoring::metrics_snapshot::add_metric(), kcenon::monitoring::storage_config::max_capacity, kcenon::monitoring::file_storage_backend::retrieve_range(), kcenon::monitoring::file_storage_backend::size(), kcenon::monitoring::metrics_snapshot::source_id, kcenon::monitoring::file_storage_backend::store(), and kcenon::monitoring::storage_config::type.

Here is the call graph for this function:

TEST_F() [12/15]

TEST_F	(	StorageBackendsTest	,
		MemoryStorageBackend	)

Definition at line 233 of file test_storage_backends.cpp.

                                                  {
    storage_config config;
    config.type = storage_backend_type::memory_buffer;
    config.max_capacity = 5;
    
    file_storage_backend backend(config); // Memory buffer uses file_storage_backend
    
    // Store snapshots
    for (const auto& snapshot : test_snapshots_) {
        auto store_result = backend.store(snapshot);
        EXPECT_TRUE(store_result.is_ok());
    }
    
    EXPECT_EQ(backend.size(), 3);
    
    // Memory backend should not create files
    // (Implementation detail - file operations are skipped for memory type)
    
    // Test all operations work
    auto retrieve_result = backend.retrieve(0);
    EXPECT_TRUE(retrieve_result.is_ok());
    
    auto range_result = backend.retrieve_range(0, 2);
    EXPECT_TRUE(range_result.is_ok());
    
    auto clear_result = backend.clear();
    EXPECT_TRUE(clear_result.is_ok());
    EXPECT_EQ(backend.size(), 0);
}

References kcenon::monitoring::file_storage_backend::clear(), kcenon::monitoring::storage_config::max_capacity, kcenon::monitoring::file_storage_backend::retrieve(), kcenon::monitoring::file_storage_backend::retrieve_range(), kcenon::monitoring::file_storage_backend::size(), kcenon::monitoring::file_storage_backend::store(), and kcenon::monitoring::storage_config::type.

Here is the call graph for this function:

TEST_F() [13/15]

TEST_F	(	StorageBackendsTest	,
		StorageBackendFactory	)

Definition at line 431 of file test_storage_backends.cpp.

                                                   {
    // Test file storage creation
    {
        storage_config file_config;
        file_config.type = storage_backend_type::file_json;
        file_config.path = (test_dir_ / "factory_test.json").string();
        file_config.max_capacity = 50;
        
        auto backend = storage_backend_factory::create_backend(file_config);
        EXPECT_TRUE(backend);
        
        auto store_result = backend->store(test_snapshots_[0]);
        EXPECT_TRUE(store_result.is_ok());
    }
    
    // Test database storage creation
    {
        storage_config db_config;
        db_config.type = storage_backend_type::database_sqlite;
        db_config.path = (test_dir_ / "factory_test.db").string();
        db_config.max_capacity = 50;
        
        auto backend = storage_backend_factory::create_backend(db_config);
        EXPECT_TRUE(backend);
        
        auto store_result = backend->store(test_snapshots_[0]);
        EXPECT_TRUE(store_result.is_ok());
    }
    
    // Test cloud storage creation
    {
        storage_config cloud_config;
        cloud_config.type = storage_backend_type::cloud_s3;
        cloud_config.path = "factory-test-bucket";
        cloud_config.max_capacity = 50;
        
        auto backend = storage_backend_factory::create_backend(cloud_config);
        EXPECT_TRUE(backend);
        
        auto store_result = backend->store(test_snapshots_[0]);
        EXPECT_TRUE(store_result.is_ok());
    }
    
    // Test invalid type
    {
        storage_config invalid_config;
        invalid_config.type = static_cast<storage_backend_type>(999);
        
        auto backend = storage_backend_factory::create_backend(invalid_config);
        EXPECT_FALSE(backend);
    }
}

References kcenon::monitoring::storage_backend_factory::create_backend(), kcenon::monitoring::storage_config::max_capacity, kcenon::monitoring::storage_config::path, and kcenon::monitoring::storage_config::type.

Here is the call graph for this function:

TEST_F() [14/15]

TEST_F	(	StorageBackendsTest	,
		StorageConfigValidation	)

Definition at line 71 of file test_storage_backends.cpp.

                                                     {
    // Valid configuration
    storage_config valid_config;
    valid_config.path = "/tmp/test.json";
    valid_config.type = storage_backend_type::file_json;
    valid_config.max_capacity = 1000;
    valid_config.batch_size = 100;
    
    auto validation = valid_config.validate();
    EXPECT_TRUE(validation.is_ok());
    
    // Invalid path (for non-memory storage)
    storage_config invalid_path;
    invalid_path.type = storage_backend_type::file_json;
    invalid_path.max_capacity = 1000;
    invalid_path.batch_size = 100;
    auto path_validation = invalid_path.validate();
    EXPECT_FALSE(path_validation.is_ok());
    EXPECT_EQ(path_validation.error().code, static_cast<int>(monitoring_error_code::invalid_configuration));
    
    // Valid memory buffer (no path required)
    storage_config memory_config;
    memory_config.type = storage_backend_type::memory_buffer;
    memory_config.max_capacity = 1000;
    memory_config.batch_size = 100;
    auto memory_validation = memory_config.validate();
    EXPECT_TRUE(memory_validation.is_ok());
    
    // Invalid capacity
    storage_config invalid_capacity;
    invalid_capacity.path = "/tmp/test";
    invalid_capacity.max_capacity = 0;
    auto capacity_validation = invalid_capacity.validate();
    EXPECT_FALSE(capacity_validation.is_ok());
    EXPECT_EQ(capacity_validation.error().code, static_cast<int>(monitoring_error_code::invalid_capacity));
    
    // Invalid batch size
    storage_config invalid_batch;
    invalid_batch.path = "/tmp/test";
    invalid_batch.max_capacity = 1000;
    invalid_batch.batch_size = 0;
    auto batch_validation = invalid_batch.validate();
    EXPECT_FALSE(batch_validation.is_ok());
    
    // Batch size larger than capacity
    storage_config batch_too_large;
    batch_too_large.path = "/tmp/test";
    batch_too_large.max_capacity = 100;
    batch_too_large.batch_size = 200;
    auto batch_large_validation = batch_too_large.validate();
    EXPECT_FALSE(batch_large_validation.is_ok());
}

References kcenon::monitoring::storage_config::batch_size, kcenon::monitoring::invalid_capacity, kcenon::monitoring::storage_config::max_capacity, kcenon::monitoring::storage_config::path, kcenon::monitoring::storage_config::type, and kcenon::monitoring::storage_config::validate().

Here is the call graph for this function:

TEST_F() [15/15]

TEST_F	(	StorageBackendsTest	,
		SupportedBackendsList	)

Definition at line 484 of file test_storage_backends.cpp.

                                                   {
    auto supported = storage_backend_factory::get_supported_backends();
    EXPECT_EQ(supported.size(), 10); // All backend types
    
    EXPECT_TRUE(std::find(supported.begin(), supported.end(), 
                         storage_backend_type::file_json) != supported.end());
    EXPECT_TRUE(std::find(supported.begin(), supported.end(), 
                         storage_backend_type::database_sqlite) != supported.end());
    EXPECT_TRUE(std::find(supported.begin(), supported.end(), 
                         storage_backend_type::cloud_s3) != supported.end());
    EXPECT_TRUE(std::find(supported.begin(), supported.end(), 
                         storage_backend_type::memory_buffer) != supported.end());
}

References kcenon::monitoring::storage_backend_factory::get_supported_backends().

Here is the call graph for this function: