C-MOVE (Retrieve) interoperability tests with DCMTK. More...

#include <catch2/catch_test_macros.hpp>
#include "dcmtk_tool.h"
#include "test_fixtures.h"
#include "kcenon/pacs/core/dicom_dataset.h"
#include "kcenon/pacs/core/dicom_file.h"
#include "kcenon/pacs/core/dicom_tag_constants.h"
#include "kcenon/pacs/encoding/transfer_syntax.h"
#include "kcenon/pacs/network/dimse/dimse_message.h"
#include "kcenon/pacs/services/query_scp.h"
#include "kcenon/pacs/services/retrieve_scp.h"
#include "kcenon/pacs/services/storage_scp.h"
#include "kcenon/pacs/services/storage_scu.h"
#include "kcenon/pacs/services/verification_scp.h"
#include <future>
#include <mutex>
#include <set>
#include <thread>
#include <vector>

Include dependency graph for test_dcmtk_move.cpp:

Go to the source code of this file.

Functions
	TEST_CASE ("C-MOVE: pacs_system SCP with DCMTK movescu", "[dcmtk][interop][move]")

	TEST_CASE ("C-MOVE: Unknown destination AE rejection", "[dcmtk][interop][move][error]")

	TEST_CASE ("C-MOVE: Connection error handling", "[dcmtk][interop][move][error]")

	TEST_CASE ("C-MOVE: Concurrent operations", "[dcmtk][interop][move][stress]")

	TEST_CASE ("C-MOVE: pacs_system SCU basic operation", "[dcmtk][interop][move]")

Detailed Description

C-MOVE (Retrieve) interoperability tests with DCMTK.

Tests bidirectional C-MOVE compatibility between pacs_system and DCMTK:

Scenario A: pacs_system SCP <- DCMTK movescu (with DCMTK storescp destination)
Scenario B: pacs_system as both SCP and destination

See also: Issue #454 - C-MOVE Interoperability Test with DCMTK; Issue #449 - DCMTK Interoperability Test Automation Epic

Definition in file test_dcmtk_move.cpp.

Function Documentation

◆ TEST_CASE() [1/5]

TEST_CASE	(	"C-MOVE: Concurrent operations"	,
		""	[dcmtk][interop][move][stress] )

Definition at line 479 of file test_dcmtk_move.cpp.

                 : Concurrent operations", "[dcmtk][interop][move][stress]") {
    if (!dcmtk_tool::is_available()) {
        SKIP("DCMTK not installed");
    }
 
    // Skip if real TCP DICOM connections are not supported yet
    if (!supports_real_tcp_dicom()) {
        SKIP("pacs_system does not support real TCP DICOM connections yet");
    }
 
    auto move_port = find_available_port();
    auto dest_port = find_available_port(move_port + 1);
    const std::string move_ae = "STRESS_MOVE_SCP";
    const std::string dest_ae = "STRESS_DEST";
 
    // Create multiple studies
    test_file_repository repository;
    std::vector<std::string> study_uids;
    for (int i = 0; i < 3; ++i) {
        auto study_uid = generate_uid();
        study_uids.push_back(study_uid);
        repository.add_file(create_test_dicom_file(
            "PAT00" + std::to_string(i),
            "PATIENT^" + std::to_string(i),
            study_uid));
    }
 
    test_directory dest_dir;
 
    // Start DCMTK storescp
    auto dcmtk_dest = dcmtk_tool::storescp(dest_port, dest_ae, dest_dir.path());
    REQUIRE(dcmtk_dest.is_running());
 
    REQUIRE(wait_for([&]() {
        return process_launcher::is_port_listening(dest_port);
    }, dcmtk_server_ready_timeout()));
 
    // Setup pacs_system Move SCP
    test_server server(move_port, move_ae);
 
    auto retrieve_scp_ptr = std::make_shared<retrieve_scp>();
    retrieve_scp_ptr->set_retrieve_handler([&repository](
        const dicom_dataset& query_keys) -> std::vector<dicom_file> {
        return repository.find_all(query_keys);
    });
 
    retrieve_scp_ptr->set_destination_resolver([dest_port, dest_ae](
        const std::string& ae) -> std::optional<std::pair<std::string, uint16_t>> {
        if (ae == dest_ae) {
            return std::make_pair("localhost", dest_port);
        }
        return std::nullopt;
    });
 
    server.register_service(retrieve_scp_ptr);
    REQUIRE(server.start());
 
    REQUIRE(wait_for([&]() {
        return process_launcher::is_port_listening(move_port);
    }, server_ready_timeout()));
 
    SECTION("Multiple concurrent move requests") {
        constexpr int num_requests = 2;
        std::vector<std::future<dcmtk_result>> futures;
        futures.reserve(num_requests);
 
        for (int i = 0; i < num_requests; ++i) {
            futures.push_back(std::async(std::launch::async, [&, i]() {
                std::vector<std::pair<std::string, std::string>> keys = {
                    {"StudyInstanceUID", study_uids[i]}
                };
                return dcmtk_tool::movescu(
                    "localhost", move_port, move_ae, dest_ae,
                    "STUDY", keys,
                    "MOVESCU_" + std::to_string(i));
            }));
        }
 
        // All should succeed
        for (size_t i = 0; i < futures.size(); ++i) {
            auto result = futures[i].get();
 
            INFO("Request " << i << " stdout: " << result.stdout_output);
            INFO("Request " << i << " stderr: " << result.stderr_output);
 
            REQUIRE(result.success());
        }
    }
}

Here is the call graph for this function:

◆ TEST_CASE() [2/5]

TEST_CASE	(	"C-MOVE: Connection error handling"	,
		""	[dcmtk][interop][move][error] )

Definition at line 445 of file test_dcmtk_move.cpp.

                 : Connection error handling", "[dcmtk][interop][move][error]") {
    if (!dcmtk_tool::is_available()) {
        SKIP("DCMTK not installed");
    }
 
    // Skip if real TCP DICOM connections are not supported yet
    if (!supports_real_tcp_dicom()) {
        SKIP("pacs_system does not support real TCP DICOM connections yet");
    }
 
    SECTION("movescu to non-existent server fails gracefully") {
        auto port = find_available_port();
 
        // Ensure nothing is listening
        REQUIRE_FALSE(process_launcher::is_port_listening(port));
 
        std::vector<std::pair<std::string, std::string>> keys = {
            {"StudyInstanceUID", "1.2.3.4.5"}
        };
 
        auto result = dcmtk_tool::movescu(
            "localhost", port, "NONEXISTENT", "DEST",
            "STUDY", keys,
            "MOVESCU", std::chrono::seconds{10});
 
        // Should fail - no server listening
        REQUIRE_FALSE(result.success());
    }
}

References kcenon::pacs::integration_test::find_available_port(), kcenon::pacs::integration_test::dcmtk_tool::is_available(), kcenon::pacs::integration_test::process_launcher::is_port_listening(), kcenon::pacs::integration_test::dcmtk_tool::movescu(), and kcenon::pacs::integration_test::supports_real_tcp_dicom().

Here is the call graph for this function:

◆ TEST_CASE() [3/5]

TEST_CASE	(	"C-MOVE: pacs_system SCP with DCMTK movescu"	,
		""	[dcmtk][interop][move] )

Definition at line 258 of file test_dcmtk_move.cpp.

                 : pacs_system SCP with DCMTK movescu", "[dcmtk][interop][move]") {
    if (!dcmtk_tool::is_available()) {
        SKIP("DCMTK not installed - skipping interoperability test");
    }
 
    // Skip if real TCP DICOM connections are not supported yet
    if (!supports_real_tcp_dicom()) {
        SKIP("pacs_system does not support real TCP DICOM connections yet");
    }
 
    // Setup: Ports and AE titles
    auto move_port = find_available_port();
    auto dest_port = find_available_port(move_port + 1);
    const std::string move_ae = "MOVE_SCP";
    const std::string dest_ae = "DEST_SCP";
 
    // Setup: File repository with test data
    test_file_repository repository;
    auto study_uid = generate_uid();
    auto file1 = create_test_dicom_file("PAT001", "DOE^JOHN", study_uid);
    auto file2 = create_test_dicom_file("PAT001", "DOE^JOHN", study_uid);
    repository.add_file(std::move(file1));
    repository.add_file(std::move(file2));
 
    // Setup: Create destination directory for DCMTK storescp
    test_directory dest_dir;
 
    // Start DCMTK storescp as destination
    auto dcmtk_dest = dcmtk_tool::storescp(dest_port, dest_ae, dest_dir.path());
    REQUIRE(dcmtk_dest.is_running());
 
    // Wait for destination to be ready
    REQUIRE(wait_for([&]() {
        return process_launcher::is_port_listening(dest_port);
    }, dcmtk_server_ready_timeout()));
 
    // Setup: pacs_system Move SCP
    test_server server(move_port, move_ae);
 
    auto retrieve_scp_ptr = std::make_shared<retrieve_scp>();
 
    // Set retrieve handler
    retrieve_scp_ptr->set_retrieve_handler([&repository](
        const dicom_dataset& query_keys) -> std::vector<dicom_file> {
        return repository.find_all(query_keys);
    });
 
    // Set destination resolver
    retrieve_scp_ptr->set_destination_resolver([dest_port, dest_ae](
        const std::string& ae_title) -> std::optional<std::pair<std::string, uint16_t>> {
        if (ae_title == dest_ae) {
            return std::make_pair("localhost", dest_port);
        }
        return std::nullopt;
    });
 
    server.register_service(retrieve_scp_ptr);
    server.register_service(std::make_shared<verification_scp>());
 
    REQUIRE(server.start());
 
    // Wait for server to be ready
    REQUIRE(wait_for([&]() {
        return process_launcher::is_port_listening(move_port);
    }, server_ready_timeout()));
 
    SECTION("C-MOVE by StudyInstanceUID succeeds") {
        std::vector<std::pair<std::string, std::string>> keys = {
            {"StudyInstanceUID", study_uid}
        };
 
        auto result = dcmtk_tool::movescu(
            "localhost", move_port, move_ae, dest_ae,
            "STUDY", keys);
 
        INFO("stdout: " << result.stdout_output);
        INFO("stderr: " << result.stderr_output);
 
        REQUIRE(result.success());
 
        // Wait for files to be received
        std::this_thread::sleep_for(std::chrono::seconds{2});
 
        // Verify files were received
        auto received_count = count_dicom_files(dest_dir.path());
        REQUIRE(received_count >= 2);
    }
 
    SECTION("C-MOVE by PatientID succeeds") {
        std::vector<std::pair<std::string, std::string>> keys = {
            {"PatientID", "PAT001"}
        };
 
        auto result = dcmtk_tool::movescu(
            "localhost", move_port, move_ae, dest_ae,
            "PATIENT", keys);
 
        INFO("stdout: " << result.stdout_output);
        INFO("stderr: " << result.stderr_output);
 
        REQUIRE(result.success());
    }
 
    SECTION("C-MOVE with empty result set completes gracefully") {
        std::vector<std::pair<std::string, std::string>> keys = {
            {"StudyInstanceUID", "1.2.3.4.5.6.7.8.9.999999"}
        };
 
        auto result = dcmtk_tool::movescu(
            "localhost", move_port, move_ae, dest_ae,
            "STUDY", keys);
 
        INFO("stdout: " << result.stdout_output);
        INFO("stderr: " << result.stderr_output);
 
        // Should succeed even with no matching results
        REQUIRE(result.success());
    }
}

Here is the call graph for this function:

◆ TEST_CASE() [4/5]

TEST_CASE	(	"C-MOVE: pacs_system SCU basic operation"	,
		""	[dcmtk][interop][move] )

Definition at line 573 of file test_dcmtk_move.cpp.

                 : pacs_system SCU basic operation", "[dcmtk][interop][move]") {
    if (!dcmtk_tool::is_available()) {
        SKIP("DCMTK not installed");
    }
 
    // Skip if real TCP DICOM connections are not supported yet
    if (!supports_real_tcp_dicom()) {
        SKIP("pacs_system does not support real TCP DICOM connections yet");
    }
 
    // Note: DCMTK doesn't provide a simple move SCP for testing.
    // This section tests pacs_system's move SCU capability by connecting
    // to our own pacs_system move SCP (which has been validated above).
 
    auto move_port = find_available_port();
    auto dest_port = find_available_port(move_port + 1);
    const std::string move_ae = "MOVE_SCP";
    const std::string dest_ae = "DEST_SCP";
 
    test_file_repository repository;
    auto study_uid = generate_uid();
    repository.add_file(create_test_dicom_file("PAT001", "DOE^JOHN", study_uid));
 
    // Received file tracker for destination
    received_file_tracker tracker;
    test_directory dest_dir;
 
    // Start pacs_system as destination storage SCP
    test_server dest_server(dest_port, dest_ae);
    auto storage_scp_ptr = std::make_shared<storage_scp>();
    storage_scp_ptr->set_handler([&tracker](
        const dicom_dataset& dataset,
        const std::string& calling_ae,
        const std::string& sop_class_uid,
        const std::string& sop_instance_uid) -> storage_status {
        tracker.on_file_received(dataset, calling_ae, sop_class_uid, sop_instance_uid);
        return storage_status::success;
    });
    dest_server.register_service(storage_scp_ptr);
    REQUIRE(dest_server.start());
 
    REQUIRE(wait_for([&]() {
        return process_launcher::is_port_listening(dest_port);
    }, server_ready_timeout()));
 
    // Start Move SCP
    test_server move_server(move_port, move_ae);
    auto retrieve_scp_ptr = std::make_shared<retrieve_scp>();
    retrieve_scp_ptr->set_retrieve_handler([&repository](
        const dicom_dataset& query_keys) -> std::vector<dicom_file> {
        return repository.find_all(query_keys);
    });
 
    retrieve_scp_ptr->set_destination_resolver([dest_port, dest_ae](
        const std::string& ae) -> std::optional<std::pair<std::string, uint16_t>> {
        if (ae == dest_ae) {
            return std::make_pair("localhost", dest_port);
        }
        return std::nullopt;
    });
 
    move_server.register_service(retrieve_scp_ptr);
    REQUIRE(move_server.start());
 
    REQUIRE(wait_for([&]() {
        return process_launcher::is_port_listening(move_port);
    }, server_ready_timeout()));
 
    SECTION("pacs_system SCU sends C-MOVE request") {
        // Connect to Move SCP
        auto connect_result = test_association::connect(
            "localhost", move_port, move_ae, "PACS_SCU",
            {std::string(study_root_move_sop_class_uid)});
 
        REQUIRE(connect_result.is_ok());
        auto& assoc = connect_result.value();
 
        REQUIRE(assoc.has_accepted_context(study_root_move_sop_class_uid));
        auto context_id = assoc.accepted_context_id(study_root_move_sop_class_uid);
        REQUIRE(context_id.has_value());
 
        // Create move request
        dicom_dataset move_keys;
        move_keys.set_string(tags::query_retrieve_level, vr_type::CS, "STUDY");
        move_keys.set_string(tags::study_instance_uid, vr_type::UI, study_uid);
 
        auto move_rq = make_c_move_rq(1, study_root_move_sop_class_uid, dest_ae);
        move_rq.set_dataset(std::move(move_keys));
 
        auto send_result = assoc.send_dimse(*context_id, move_rq);
        REQUIRE(send_result.is_ok());
 
        // Receive move responses
        bool final_received = false;
        while (!final_received) {
            auto recv_result = assoc.receive_dimse(std::chrono::seconds{30});
            REQUIRE(recv_result.is_ok());
 
            auto& [recv_ctx, rsp] = recv_result.value();
            REQUIRE(rsp.command() == command_field::c_move_rsp);
 
            if (rsp.status() == status_success) {
                final_received = true;
            } else if (rsp.status() != status_pending) {
                INFO("Unexpected status: " << static_cast<int>(rsp.status()));
                FAIL("Unexpected C-MOVE response status");
            }
        }
 
        // Wait for destination to receive files
        std::this_thread::sleep_for(std::chrono::seconds{1});
 
        // Verify file was received
        REQUIRE(tracker.count() >= 1);
    }
}

Here is the call graph for this function:

◆ TEST_CASE() [5/5]

TEST_CASE	(	"C-MOVE: Unknown destination AE rejection"	,
		""	[dcmtk][interop][move][error] )

Definition at line 382 of file test_dcmtk_move.cpp.

                 : Unknown destination AE rejection", "[dcmtk][interop][move][error]") {
    if (!dcmtk_tool::is_available()) {
        SKIP("DCMTK not installed");
    }
 
    // Skip if real TCP DICOM connections are not supported yet
    if (!supports_real_tcp_dicom()) {
        SKIP("pacs_system does not support real TCP DICOM connections yet");
    }
 
    auto port = find_available_port();
    const std::string ae_title = "MOVE_SCP";
 
    test_file_repository repository;
    auto study_uid = generate_uid();
    repository.add_file(create_test_dicom_file("PAT001", "DOE^JOHN", study_uid));
 
    test_server server(port, ae_title);
 
    auto retrieve_scp_ptr = std::make_shared<retrieve_scp>();
    retrieve_scp_ptr->set_retrieve_handler([&repository](
        const dicom_dataset& query_keys) -> std::vector<dicom_file> {
        return repository.find_all(query_keys);
    });
 
    // Only resolve known AE titles
    retrieve_scp_ptr->set_destination_resolver([](
        const std::string& ae) -> std::optional<std::pair<std::string, uint16_t>> {
        if (ae == "KNOWN_DEST") {
            return std::make_pair("localhost", 11113);
        }
        return std::nullopt;  // Unknown AE
    });
 
    server.register_service(retrieve_scp_ptr);
    REQUIRE(server.start());
 
    REQUIRE(wait_for([&]() {
        return process_launcher::is_port_listening(port);
    }, server_ready_timeout()));
 
    SECTION("Unknown destination AE is rejected") {
        std::vector<std::pair<std::string, std::string>> keys = {
            {"StudyInstanceUID", study_uid}
        };
 
        // Use unknown destination AE
        auto result = dcmtk_tool::movescu(
            "localhost", port, ae_title, "UNKNOWN_DEST",
            "STUDY", keys);
 
        INFO("stdout: " << result.stdout_output);
        INFO("stderr: " << result.stderr_output);
 
        // Should fail due to unknown destination
        REQUIRE_FALSE(result.success());
    }
}

Here is the call graph for this function:

Functions

Detailed Description

Function Documentation

◆ TEST_CASE() [1/5]

◆ TEST_CASE() [2/5]

◆ TEST_CASE() [3/5]

◆ TEST_CASE() [4/5]

◆ TEST_CASE() [5/5]