test_xa_storage.cpp

Go to the documentation of this file.

 
#include "test_fixtures.h"
#include "kcenon/pacs/storage/file_storage.h"
#include <catch2/catch_test_macros.hpp>
#include <iostream>
 
using namespace kcenon::pacs::integration_test;
using namespace kcenon::pacs::core;
using namespace kcenon::pacs::network;
using namespace kcenon::pacs::services;
using namespace kcenon::pacs::storage;
using namespace kcenon::pacs::encoding;
using namespace kcenon::pacs::network::dimse;
 
// Define missing tag locally
constexpr dicom_tag number_of_frames{0x0028, 0x0008};
 
namespace {
 
class xa_pacs_server {
public:
    explicit xa_pacs_server(uint16_t port, const std::string& ae_title = "XA_SCP")
        : port_(port)
        , ae_title_(ae_title)
        , test_dir_("xa_server_test_")
        , storage_dir_(test_dir_.path() / "archive") {
 
        std::filesystem::create_directories(storage_dir_);
 
        server_config config;
        config.ae_title = ae_title_;
        config.port = port_;
        config.max_associations = 20;
        config.idle_timeout = std::chrono::seconds{5};  // Short timeout for tests
        config.implementation_class_uid = "1.2.826.0.1.3680043.9.9999.1";
        config.implementation_version_name = "TEST_PACS";
 
        server_ = std::make_unique<dicom_server>(config);
 
        file_storage_config fs_config;
        fs_config.root_path = storage_dir_;
        fs_config.naming = naming_scheme::flat;
        file_storage_ = std::make_unique<file_storage>(fs_config);
    }
 
    bool initialize() {
        server_->register_service(std::make_shared<verification_scp>());
 
        storage_scp_config scp_config;
        scp_config.accepted_sop_classes.push_back("1.2.840.10008.5.1.4.1.1.12.1"); // XA Image Storage
        auto storage_scp_ptr = std::make_shared<storage_scp>(scp_config);
        
        storage_scp_ptr->set_handler([this](
            const dicom_dataset& dataset,
            const std::string&,
            const std::string&,
            const std::string&) -> storage_status {
 
            auto result = file_storage_->store(dataset);
            return result.is_ok() ? storage_status::success : storage_status::storage_error;
        });
        server_->register_service(storage_scp_ptr);
 
        return true;
    }
 
    bool start() {
        auto result = server_->start();
        if (result.is_ok()) {
            std::this_thread::sleep_for(std::chrono::milliseconds{100});
            return true;
        }
        return false;
    }
 
    void stop() {
        server_->stop();
    }
 
    uint16_t port() const { return port_; }
    const std::string& ae_title() const { return ae_title_; }
    const std::filesystem::path& storage_path() const { return storage_dir_; }
 
private:
    uint16_t port_;
    std::string ae_title_;
    test_directory test_dir_;
    std::filesystem::path storage_dir_;
    std::unique_ptr<dicom_server> server_;
    std::unique_ptr<file_storage> file_storage_;
};
 
} // namespace
 
TEST_CASE("XA Storage Integration", "[integration][xa][storage]") {
    // Setup test environment
    auto port = find_available_port();
    xa_pacs_server server(port, "XA_SCP");
    REQUIRE(server.initialize());
    REQUIRE(server.start());
 
    SECTION("Scenario 1: Basic XA Storage") {
        // Create XA dataset
        auto ds = generate_xa_dataset();
        auto instance_uid = ds.get_string(tags::sop_instance_uid);
 
        // Connect and store
        auto assoc_result = test_association::connect(
            "127.0.0.1", port, "XA_SCP", "TEST_SCU",
            {"1.2.840.10008.5.1.4.1.1.12.1", "1.2.840.10008.1.1"});
        REQUIRE(assoc_result.is_ok());
 
        auto association = std::move(assoc_result.value());
 
        // Verify connection with C-ECHO
        auto context_id_opt = association.accepted_context_id(verification_sop_class_uid);
        if (!context_id_opt) {
            // Known issue: Global negotiation failure
            WARN("Verification SOP Class not accepted (Global Issue)");
        } else {
            auto echo_rq = make_c_echo_rq(1, verification_sop_class_uid);
            auto send_result = association.send_dimse(*context_id_opt, echo_rq);
            CHECK(send_result.is_ok());
            auto recv_result = association.receive_dimse(std::chrono::seconds{5});
            CHECK(recv_result.is_ok());
        }
 
        storage_scu scu;
        auto store_result = scu.store(association, ds);
        if (store_result.is_err()) {
            FAIL("Store failed: " << store_result.error().message);
        }
        CHECK(store_result.value().is_success()); // Success
 
        // Verify file exists
        auto stored_path = server.storage_path() / (instance_uid + ".dcm");
        CHECK(std::filesystem::exists(stored_path));
 
        // Release association
        [[maybe_unused]] auto release_result = association.release();
    }
 
    SECTION("Scenario 2: XA IOD Validation") {
        // Valid dataset
        auto valid_ds = generate_xa_dataset();
 
        // Connect
        auto assoc_result = test_association::connect(
            "127.0.0.1", port, "XA_SCP", "TEST_SCU",
            {"1.2.840.10008.5.1.4.1.1.12.1"});
        REQUIRE(assoc_result.is_ok());
        auto association = std::move(assoc_result.value());
 
        // Store valid
        storage_scu scu;
        auto result_valid = scu.store(association, valid_ds);
        if (result_valid.is_err()) {
            FAIL("Store valid failed: " << result_valid.error().message);
        }
        CHECK(result_valid.value().is_success());
 
        // Release association
        [[maybe_unused]] auto release_result = association.release();
 
        // TODO: Implement invalid dataset test once dataset API is confirmed.
    }
 
    SECTION("Scenario 3: Multi-frame XA Storage") {
        auto ds = generate_xa_dataset();
        ds.set_string(number_of_frames, vr_type::IS, "10");
        // Update pixel data for 10 frames
        std::vector<uint16_t> pixel_data(512 * 512 * 10, 128);
        ds.insert(dicom_element(tags::pixel_data, vr_type::OW,
            std::span<const uint8_t>(reinterpret_cast<const uint8_t*>(pixel_data.data()), pixel_data.size() * sizeof(uint16_t))));
 
        auto assoc_result = test_association::connect(
            "127.0.0.1", port, "XA_SCP", "TEST_SCU",
            {"1.2.840.10008.5.1.4.1.1.12.1"});
        REQUIRE(assoc_result.is_ok());
        auto association = std::move(assoc_result.value());
 
        storage_scu scu;
        auto result = scu.store(association, ds);
        if (result.is_err()) {
            FAIL("Multi-frame store failed: " << result.error().message);
        }
        CHECK(result.value().is_success());
 
        // Release association
        [[maybe_unused]] auto release_result = association.release();
    }
 
    SECTION("Scenario 4: XA Specific Attributes") {
        auto ds = generate_xa_dataset();
        // Verify we can set/get XA specific tags
 
        auto assoc_result = test_association::connect(
            "127.0.0.1", port, "XA_SCP", "TEST_SCU",
            {"1.2.840.10008.5.1.4.1.1.12.1"});
        REQUIRE(assoc_result.is_ok());
        auto association = std::move(assoc_result.value());
 
        storage_scu scu;
        auto result = scu.store(association, ds);
        if (result.is_err()) {
            FAIL("XA attributes store failed: " << result.error().message);
        }
        CHECK(result.value().is_success());
 
        // Release association
        [[maybe_unused]] auto release_result = association.release();
    }
 
    // Stop server explicitly
    server.stop();
}