test_support.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include "service_interfaces.h"
#include "service_registration.h"
 
#include <kcenon/pacs/core/dicom_dataset.h>
#include <kcenon/pacs/core/dicom_tag_constants.h>
 
#include <kcenon/common/di/service_container.h>
 
#include <functional>
#include <map>
#include <memory>
#include <mutex>
#include <string>
#include <vector>
 
namespace kcenon::pacs::di::test {
 
// =============================================================================
// Mock Storage Implementation
// =============================================================================
 
class MockStorage : public IDicomStorage {
public:
    MockStorage() = default;
    ~MockStorage() override = default;
 
    // =========================================================================
    // storage_interface Implementation
    // =========================================================================
 
    [[nodiscard]] storage::VoidResult store(const core::dicom_dataset& dataset) override {
        std::lock_guard<std::mutex> lock(mutex_);
 
        auto uid = dataset.get_string(core::tags::sop_instance_uid);
        if (uid.empty()) {
            return kcenon::common::make_error<std::monostate>(
                -1, "Dataset missing SOP Instance UID", "MockStorage");
        }
 
        datasets_[uid] = dataset;
        store_calls_.push_back(uid);
 
        if (on_store_) {
            on_store_(dataset);
        }
 
        return storage::VoidResult::ok({});
    }
 
    [[nodiscard]] storage::Result<core::dicom_dataset>
        retrieve(std::string_view sop_instance_uid) override {
        std::lock_guard<std::mutex> lock(mutex_);
 
        auto it = datasets_.find(std::string(sop_instance_uid));
        if (it == datasets_.end()) {
            return kcenon::common::make_error<core::dicom_dataset>(
                -1, "Instance not found", "MockStorage");
        }
 
        return storage::Result<core::dicom_dataset>::ok(it->second);
    }
 
    [[nodiscard]] storage::VoidResult remove(std::string_view sop_instance_uid) override {
        std::lock_guard<std::mutex> lock(mutex_);
        datasets_.erase(std::string(sop_instance_uid));
        return storage::VoidResult::ok({});
    }
 
    [[nodiscard]] bool exists(std::string_view sop_instance_uid) const override {
        std::lock_guard<std::mutex> lock(mutex_);
        return datasets_.find(std::string(sop_instance_uid)) != datasets_.end();
    }
 
    [[nodiscard]] storage::Result<std::vector<core::dicom_dataset>>
        find(const core::dicom_dataset& /*query*/) override {
        std::lock_guard<std::mutex> lock(mutex_);
 
        std::vector<core::dicom_dataset> results;
        for (const auto& [uid, dataset] : datasets_) {
            results.push_back(dataset);
        }
        return storage::Result<std::vector<core::dicom_dataset>>::ok(std::move(results));
    }
 
    [[nodiscard]] storage::storage_statistics get_statistics() const override {
        std::lock_guard<std::mutex> lock(mutex_);
 
        storage::storage_statistics stats;
        stats.total_instances = datasets_.size();
        return stats;
    }
 
    [[nodiscard]] storage::VoidResult verify_integrity() override {
        return storage::VoidResult::ok({});
    }
 
    // =========================================================================
    // Test Utilities
    // =========================================================================
 
    [[nodiscard]] std::size_t store_count() const {
        std::lock_guard<std::mutex> lock(mutex_);
        return store_calls_.size();
    }
 
    [[nodiscard]] std::vector<std::string> stored_uids() const {
        std::lock_guard<std::mutex> lock(mutex_);
        return store_calls_;
    }
 
    void clear() {
        std::lock_guard<std::mutex> lock(mutex_);
        datasets_.clear();
        store_calls_.clear();
    }
 
    void on_store(std::function<void(const core::dicom_dataset&)> callback) {
        on_store_ = std::move(callback);
    }
 
private:
    mutable std::mutex mutex_;
    std::map<std::string, core::dicom_dataset> datasets_;
    std::vector<std::string> store_calls_;
    std::function<void(const core::dicom_dataset&)> on_store_;
};
 
// =============================================================================
// Mock Network Implementation
// =============================================================================
 
class MockNetwork : public IDicomNetwork {
public:
    MockNetwork() = default;
    ~MockNetwork() override = default;
 
    [[nodiscard]] std::unique_ptr<network::dicom_server> create_server(
        const network::server_config& config,
        const integration::tls_config& /*tls_cfg*/) override {
        std::lock_guard<std::mutex> lock(mutex_);
        server_configs_.push_back(config);
 
        // Return nullptr for mock - actual server creation not needed in tests
        return nullptr;
    }
 
    [[nodiscard]] integration::Result<integration::network_adapter::session_ptr>
        connect(const integration::connection_config& config) override {
        std::lock_guard<std::mutex> lock(mutex_);
        connection_attempts_.push_back({config.host, config.port});
 
        if (fail_connections_) {
            return integration::error_info{"Connection refused (mock)"};
        }
 
        // Return nullptr session for mock
        return integration::network_adapter::session_ptr{nullptr};
    }
 
    [[nodiscard]] integration::Result<integration::network_adapter::session_ptr>
        connect(const std::string& host, uint16_t port,
                std::chrono::milliseconds /*timeout*/) override {
        integration::connection_config config;
        config.host = host;
        config.port = port;
        return connect(config);
    }
 
    // =========================================================================
    // Test Utilities
    // =========================================================================
 
    [[nodiscard]] std::size_t connection_attempt_count() const {
        std::lock_guard<std::mutex> lock(mutex_);
        return connection_attempts_.size();
    }
 
    [[nodiscard]] std::size_t server_creation_count() const {
        std::lock_guard<std::mutex> lock(mutex_);
        return server_configs_.size();
    }
 
    void set_fail_connections(bool fail) {
        std::lock_guard<std::mutex> lock(mutex_);
        fail_connections_ = fail;
    }
 
    void clear() {
        std::lock_guard<std::mutex> lock(mutex_);
        connection_attempts_.clear();
        server_configs_.clear();
    }
 
private:
    mutable std::mutex mutex_;
    std::vector<std::pair<std::string, uint16_t>> connection_attempts_;
    std::vector<network::server_config> server_configs_;
    bool fail_connections_ = false;
};
 
// =============================================================================
// Test Container Builder
// =============================================================================
 
class TestContainerBuilder {
public:
    TestContainerBuilder() = default;
 
    TestContainerBuilder& with_storage(std::shared_ptr<MockStorage> storage) {
        mock_storage_ = std::move(storage);
        return *this;
    }
 
    TestContainerBuilder& with_mock_storage() {
        mock_storage_ = std::make_shared<MockStorage>();
        return *this;
    }
 
    TestContainerBuilder& with_network(std::shared_ptr<MockNetwork> network) {
        mock_network_ = std::move(network);
        return *this;
    }
 
    TestContainerBuilder& with_mock_network() {
        mock_network_ = std::make_shared<MockNetwork>();
        return *this;
    }
 
    [[nodiscard]] std::shared_ptr<kcenon::common::di::service_container> build() {
        auto container = std::make_shared<kcenon::common::di::service_container>();
 
        if (mock_storage_) {
            container->register_instance<IDicomStorage>(mock_storage_);
        }
 
        if (mock_network_) {
            container->register_instance<IDicomNetwork>(mock_network_);
        }
 
        return container;
    }
 
    [[nodiscard]] std::shared_ptr<MockStorage> storage() const {
        return mock_storage_;
    }
 
    [[nodiscard]] std::shared_ptr<MockNetwork> network() const {
        return mock_network_;
    }
 
private:
    std::shared_ptr<MockStorage> mock_storage_;
    std::shared_ptr<MockNetwork> mock_network_;
};
 
// =============================================================================
// Convenience Functions
// =============================================================================
 
[[nodiscard]] inline std::shared_ptr<kcenon::common::di::service_container>
create_test_container() {
    return TestContainerBuilder()
        .with_mock_storage()
        .with_mock_network()
        .build();
}
 
inline void register_mock_storage(
    kcenon::common::di::IServiceContainer& container,
    std::shared_ptr<MockStorage> mock) {
    container.register_instance<IDicomStorage>(std::move(mock));
}
 
inline void register_mock_network(
    kcenon::common::di::IServiceContainer& container,
    std::shared_ptr<MockNetwork> mock) {
    container.register_instance<IDicomNetwork>(std::move(mock));
}
 
}  // namespace kcenon::pacs::di::test