test_store_query.cpp File Reference

Scenario 2: Store and Query Workflow Tests. More...

#include "test_fixtures.h"
#include <catch2/catch_test_macros.hpp>
#include <catch2/matchers/catch_matchers_string.hpp>
#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 "kcenon/pacs/storage/file_storage.h"
#include "kcenon/pacs/storage/index_database.h"
#include <memory>

Include dependency graph for test_store_query.cpp:

Go to the source code of this file.

Functions
	TEST_CASE ("Store single DICOM file and query", "[store_query][basic]")
	TEST_CASE ("Store multiple files from same study", "[store_query][multi]")
	TEST_CASE ("Store files from multiple modalities", "[store_query][modality]")
	TEST_CASE ("Query with wildcards", "[store_query][wildcard]")

Detailed Description

Scenario 2: Store and Query Workflow Tests.

Tests the complete storage and query workflow:

1. Start PACS Server
2. Store DICOM files via Storage SCU
3. Query via Query SCU -> Verify results
4. Retrieve via Retrieve SCU -> Verify files match
5. Stop PACS Server

See also

Issue #111 - Integration Test Suite

Definition in file test_store_query.cpp.

Function Documentation

TEST_CASE() [1/4]

TEST_CASE	(	"Query with wildcards"	,
		""	[store_query][wildcard] )

Definition at line 590 of file test_store_query.cpp.

                                                             {
    auto port = find_available_port();
    simple_pacs_server server(port, "TEST_PACS");
 
    REQUIRE(server.initialize());
    REQUIRE(server.start());
 
    // Store multiple patients
    std::vector<std::string> patient_names = {
        "SMITH^JOHN", "SMITH^JANE", "JONES^WILLIAM"
    };
 
    association_config config;
    config.calling_ae_title = "STORE_SCU";
    config.called_ae_title = server.ae_title();
    config.implementation_class_uid = "1.2.826.0.1.3680043.9.9999.2";
    config.proposed_contexts.push_back({
        1,
        "1.2.840.10008.5.1.4.1.1.2",
        {"1.2.840.10008.1.2.1"}
    });
 
    auto connect_result = association::connect(
        "localhost", port, config, default_timeout());
    REQUIRE(connect_result.is_ok());
 
    auto& assoc = connect_result.value();
    storage_scu scu;
 
    for (const auto& name : patient_names) {
        auto ds = generate_ct_dataset();
        ds.set_string(tags::patient_name, vr_type::PN, name);
        ds.set_string(tags::patient_id, vr_type::LO, "PID_" + name.substr(0, 5));
 
        auto result = scu.store(assoc, ds);
        REQUIRE(result.is_ok());
    }
 
    (void)assoc.release(default_timeout());
 
    // Query with wildcard
    association_config query_config;
    query_config.calling_ae_title = "QUERY_SCU";
    query_config.called_ae_title = server.ae_title();
    query_config.implementation_class_uid = "1.2.826.0.1.3680043.9.9999.3";
    query_config.proposed_contexts.push_back({
        1,
        std::string(study_root_find_sop_class_uid),
        {"1.2.840.10008.1.2.1"}
    });
 
    auto query_connect = association::connect(
        "localhost", port, query_config, default_timeout());
    REQUIRE(query_connect.is_ok());
 
    auto& query_assoc = query_connect.value();
 
    // Query for all SMITH patients
    dicom_dataset query_keys;
    query_keys.set_string(tags::query_retrieve_level, vr_type::CS, "STUDY");
    query_keys.set_string(tags::patient_name, vr_type::PN, "SMITH*");
    query_keys.set_string(tags::study_instance_uid, vr_type::UI, "");
 
    auto context_id = *query_assoc.accepted_context_id(
        study_root_find_sop_class_uid);
 
    auto find_rq = make_c_find_rq(1, study_root_find_sop_class_uid);
    find_rq.set_dataset(std::move(query_keys));
    (void)query_assoc.send_dimse(context_id, find_rq);
 
    std::vector<dicom_dataset> results;
    while (true) {
        auto recv_result = query_assoc.receive_dimse(default_timeout());
        if (recv_result.is_err()) break;
 
        auto& [recv_ctx, rsp] = recv_result.value();
        if (rsp.status() == status_success) break;
        if (rsp.status() == status_pending && rsp.has_dataset()) {
            auto ds_result = rsp.dataset();
            if (ds_result.is_ok()) {
                results.push_back(ds_result.value().get());
            }
        }
    }
 
    // Should find 2 SMITH patients
    REQUIRE(results.size() == 2);
 
    (void)query_assoc.release(default_timeout());
    server.stop();
}

References kcenon::pacs::network::association_config::called_ae_title, kcenon::pacs::network::association_config::calling_ae_title, kcenon::pacs::integration_test::default_timeout(), kcenon::pacs::integration_test::find_available_port(), kcenon::pacs::integration_test::generate_ct_dataset(), kcenon::pacs::network::association_config::implementation_class_uid, kcenon::pacs::network::dimse::make_c_find_rq(), name, kcenon::pacs::network::association_config::proposed_contexts, kcenon::pacs::core::dicom_dataset::set_string(), kcenon::pacs::services::storage_scu::store(), and kcenon::pacs::services::study_root_find_sop_class_uid.

Here is the call graph for this function:

TEST_CASE() [2/4]

TEST_CASE	(	"Store files from multiple modalities"	,
		""	[store_query][modality] )

Definition at line 495 of file test_store_query.cpp.

                                                                             {
    auto port = find_available_port();
    simple_pacs_server server(port, "TEST_PACS");
 
    REQUIRE(server.initialize());
    REQUIRE(server.start());
 
    // Store CT and MR images
    auto ct_dataset = generate_ct_dataset();
    auto mr_dataset = generate_mr_dataset();
 
    association_config config;
    config.calling_ae_title = "STORE_SCU";
    config.called_ae_title = server.ae_title();
    config.implementation_class_uid = "1.2.826.0.1.3680043.9.9999.2";
    config.proposed_contexts.push_back({
        1,
        "1.2.840.10008.5.1.4.1.1.2",  // CT Image Storage
        {"1.2.840.10008.1.2.1"}
    });
    config.proposed_contexts.push_back({
        3,
        "1.2.840.10008.5.1.4.1.1.4",  // MR Image Storage
        {"1.2.840.10008.1.2.1"}
    });
 
    auto connect_result = association::connect(
        "localhost", port, config, default_timeout());
    REQUIRE(connect_result.is_ok());
 
    auto& assoc = connect_result.value();
    storage_scu scu;
 
    auto ct_result = scu.store(assoc, ct_dataset);
    REQUIRE(ct_result.is_ok());
 
    auto mr_result = scu.store(assoc, mr_dataset);
    REQUIRE(mr_result.is_ok());
 
    (void)assoc.release(default_timeout());
 
    REQUIRE(server.stored_count() == 2);
 
    // Query by modality
    association_config query_config;
    query_config.calling_ae_title = "QUERY_SCU";
    query_config.called_ae_title = server.ae_title();
    query_config.implementation_class_uid = "1.2.826.0.1.3680043.9.9999.3";
    query_config.proposed_contexts.push_back({
        1,
        std::string(study_root_find_sop_class_uid),
        {"1.2.840.10008.1.2.1"}
    });
 
    auto query_connect = association::connect(
        "localhost", port, query_config, default_timeout());
    REQUIRE(query_connect.is_ok());
 
    auto& query_assoc = query_connect.value();
 
    // Query for CT studies only
    dicom_dataset ct_query;
    ct_query.set_string(tags::query_retrieve_level, vr_type::CS, "STUDY");
    ct_query.set_string(tags::modalities_in_study, vr_type::CS, "CT");
    ct_query.set_string(tags::study_instance_uid, vr_type::UI, "");
 
    auto context_id = *query_assoc.accepted_context_id(
        study_root_find_sop_class_uid);
 
    auto find_rq = make_c_find_rq(1, study_root_find_sop_class_uid);
    find_rq.set_dataset(std::move(ct_query));
    (void)query_assoc.send_dimse(context_id, find_rq);
 
    std::vector<dicom_dataset> ct_results;
    while (true) {
        auto recv_result = query_assoc.receive_dimse(default_timeout());
        if (recv_result.is_err()) break;
 
        auto& [recv_ctx, rsp] = recv_result.value();
        if (rsp.status() == status_success) break;
        if (rsp.status() == status_pending && rsp.has_dataset()) {
            auto ds_result = rsp.dataset();
            if (ds_result.is_ok()) {
                ct_results.push_back(ds_result.value().get());
            }
        }
    }
 
    // Should find exactly 1 CT study
    REQUIRE(ct_results.size() == 1);
 
    (void)query_assoc.release(default_timeout());
    server.stop();
}

References kcenon::pacs::network::association_config::called_ae_title, kcenon::pacs::network::association_config::calling_ae_title, kcenon::pacs::integration_test::default_timeout(), kcenon::pacs::integration_test::find_available_port(), kcenon::pacs::integration_test::generate_ct_dataset(), kcenon::pacs::integration_test::generate_mr_dataset(), kcenon::pacs::network::association_config::implementation_class_uid, kcenon::pacs::network::dimse::make_c_find_rq(), kcenon::pacs::network::association_config::proposed_contexts, kcenon::pacs::core::dicom_dataset::set_string(), kcenon::pacs::services::storage_scu::store(), and kcenon::pacs::services::study_root_find_sop_class_uid.

Here is the call graph for this function:

TEST_CASE() [3/4]

TEST_CASE	(	"Store multiple files from same study"	,
		""	[store_query][multi] )

Definition at line 388 of file test_store_query.cpp.

                                                                          {
    auto port = find_available_port();
    simple_pacs_server server(port, "TEST_PACS");
 
    REQUIRE(server.initialize());
    REQUIRE(server.start());
 
    // Generate test data - multiple images in same study
    auto study_uid = generate_uid();
    auto series_uid = generate_uid();
    constexpr int num_images = 5;
 
    std::vector<dicom_dataset> datasets;
    for (int i = 0; i < num_images; ++i) {
        auto ds = generate_ct_dataset(study_uid, series_uid);
        ds.set_string(tags::instance_number, vr_type::IS, std::to_string(i + 1));
        datasets.push_back(std::move(ds));
    }
 
    // Store all images
    association_config config;
    config.calling_ae_title = "STORE_SCU";
    config.called_ae_title = server.ae_title();
    config.implementation_class_uid = "1.2.826.0.1.3680043.9.9999.2";
    config.proposed_contexts.push_back({
        1,
        "1.2.840.10008.5.1.4.1.1.2",  // CT Image Storage
        {"1.2.840.10008.1.2.1", "1.2.840.10008.1.2"}
    });
 
    auto connect_result = association::connect(
        "localhost", port, config, default_timeout());
    REQUIRE(connect_result.is_ok());
 
    auto& assoc = connect_result.value();
 
    storage_scu_config scu_config;
    storage_scu scu{scu_config};
 
    for (const auto& ds : datasets) {
        auto result = scu.store(assoc, ds);
        REQUIRE(result.is_ok());
        REQUIRE(result.value().is_success());
    }
 
    (void)assoc.release(default_timeout());
 
    REQUIRE(server.stored_count() == num_images);
 
    // Query at series level - should return 1 series with num_images
    association_config query_config;
    query_config.calling_ae_title = "QUERY_SCU";
    query_config.called_ae_title = server.ae_title();
    query_config.implementation_class_uid = "1.2.826.0.1.3680043.9.9999.3";
    query_config.proposed_contexts.push_back({
        1,
        std::string(study_root_find_sop_class_uid),
        {"1.2.840.10008.1.2.1", "1.2.840.10008.1.2"}
    });
 
    auto query_connect = association::connect(
        "localhost", port, query_config, default_timeout());
    REQUIRE(query_connect.is_ok());
 
    auto& query_assoc = query_connect.value();
 
    dicom_dataset query_keys;
    query_keys.set_string(tags::query_retrieve_level, vr_type::CS, "SERIES");
    query_keys.set_string(tags::study_instance_uid, vr_type::UI, study_uid);
    query_keys.set_string(tags::series_instance_uid, vr_type::UI, "");
    query_keys.set_string(tags::number_of_series_related_instances, vr_type::IS, "");
 
    auto context_id = *query_assoc.accepted_context_id(
        study_root_find_sop_class_uid);
 
    auto find_rq = make_c_find_rq(1, study_root_find_sop_class_uid);
    find_rq.set_dataset(std::move(query_keys));
    (void)query_assoc.send_dimse(context_id, find_rq);
 
    std::vector<dicom_dataset> results;
    while (true) {
        auto recv_result = query_assoc.receive_dimse(default_timeout());
        if (recv_result.is_err()) break;
 
        auto& [recv_ctx, rsp] = recv_result.value();
        if (rsp.status() == status_success) break;
        if (rsp.status() == status_pending && rsp.has_dataset()) {
            auto ds_result = rsp.dataset();
            if (ds_result.is_ok()) {
                results.push_back(ds_result.value().get());
            }
        }
    }
 
    REQUIRE(results.size() == 1);
    REQUIRE(results[0].get_string(tags::series_instance_uid) == series_uid);
 
    // Check number of instances in series
    auto num_instances_str = results[0].get_string(tags::number_of_series_related_instances);
    if (!num_instances_str.empty()) {
        REQUIRE(std::stoi(num_instances_str) == num_images);
    }
 
    (void)query_assoc.release(default_timeout());
    server.stop();
}

References kcenon::pacs::network::association_config::called_ae_title, kcenon::pacs::network::association_config::calling_ae_title, kcenon::pacs::integration_test::default_timeout(), kcenon::pacs::integration_test::find_available_port(), kcenon::pacs::integration_test::generate_ct_dataset(), kcenon::pacs::integration_test::generate_uid(), kcenon::pacs::network::association_config::implementation_class_uid, kcenon::pacs::network::dimse::make_c_find_rq(), kcenon::pacs::network::association_config::proposed_contexts, kcenon::pacs::core::dicom_dataset::set_string(), and kcenon::pacs::services::study_root_find_sop_class_uid.

Here is the call graph for this function:

TEST_CASE() [4/4]

TEST_CASE	(	"Store single DICOM file and query"	,
		""	[store_query][basic] )

Definition at line 280 of file test_store_query.cpp.

                                                                       {
    auto port = find_available_port();
    simple_pacs_server server(port, "TEST_PACS");
 
    REQUIRE(server.initialize());
    REQUIRE(server.start());
 
    SECTION("Store CT image and query at study level") {
        // Generate test dataset
        auto study_uid = generate_uid();
        auto dataset = generate_ct_dataset(study_uid);
 
        // Configure association for storage
        association_config config;
        config.calling_ae_title = "STORE_SCU";
        config.called_ae_title = server.ae_title();
        config.implementation_class_uid = "1.2.826.0.1.3680043.9.9999.2";
        config.proposed_contexts.push_back({
            1,
            "1.2.840.10008.5.1.4.1.1.2",  // CT Image Storage
            {"1.2.840.10008.1.2.1", "1.2.840.10008.1.2"}
        });
 
        auto connect_result = association::connect(
            "localhost", port, config, default_timeout());
        REQUIRE(connect_result.is_ok());
 
        auto& assoc = connect_result.value();
 
        // Create storage SCU and send
        storage_scu_config scu_config;
        scu_config.response_timeout = default_timeout();
        storage_scu scu{scu_config};
 
        auto store_result = scu.store(assoc, dataset);
        REQUIRE(store_result.is_ok());
        REQUIRE(store_result.value().is_success());
 
        (void)assoc.release(default_timeout());
 
        // Verify stored count
        REQUIRE(server.stored_count() == 1);
 
        // Query the stored study
        association_config query_config;
        query_config.calling_ae_title = "QUERY_SCU";
        query_config.called_ae_title = server.ae_title();
        query_config.implementation_class_uid = "1.2.826.0.1.3680043.9.9999.3";
        query_config.proposed_contexts.push_back({
            1,
            std::string(study_root_find_sop_class_uid),
            {"1.2.840.10008.1.2.1", "1.2.840.10008.1.2"}
        });
 
        auto query_connect = association::connect(
            "localhost", port, query_config, default_timeout());
        REQUIRE(query_connect.is_ok());
 
        auto& query_assoc = query_connect.value();
 
        // Create query keys
        dicom_dataset query_keys;
        query_keys.set_string(tags::query_retrieve_level, vr_type::CS, "STUDY");
        query_keys.set_string(tags::study_instance_uid, vr_type::UI, study_uid);
        query_keys.set_string(tags::patient_name, vr_type::PN, "");  // Return all
 
        auto context_id = *query_assoc.accepted_context_id(
            study_root_find_sop_class_uid);
 
        // Send C-FIND
        auto find_rq = make_c_find_rq(
            1,
            study_root_find_sop_class_uid
        );
        find_rq.set_dataset(std::move(query_keys));
        auto send_result = query_assoc.send_dimse(context_id, find_rq);
        REQUIRE(send_result.is_ok());
 
        // Receive responses
        std::vector<dicom_dataset> query_results;
        while (true) {
            auto recv_result = query_assoc.receive_dimse(default_timeout());
            REQUIRE(recv_result.is_ok());
 
            auto& [recv_ctx, rsp] = recv_result.value();
            if (rsp.status() == status_success) {
                break;  // Final response
            } else if (rsp.status() == status_pending) {
                if (rsp.has_dataset()) {
                    auto ds_result = rsp.dataset();
                    if (ds_result.is_ok()) {
                        query_results.push_back(ds_result.value().get());
                    }
                }
            } else {
                FAIL("Unexpected query status");
            }
        }
 
        REQUIRE(query_results.size() == 1);
        REQUIRE(query_results[0].get_string(tags::study_instance_uid) == study_uid);
 
        (void)query_assoc.release(default_timeout());
    }
 
    server.stop();
}

References kcenon::pacs::network::association_config::called_ae_title, kcenon::pacs::network::association_config::calling_ae_title, kcenon::pacs::integration_test::default_timeout(), kcenon::pacs::integration_test::find_available_port(), kcenon::pacs::integration_test::generate_ct_dataset(), kcenon::pacs::integration_test::generate_uid(), kcenon::pacs::network::association_config::implementation_class_uid, kcenon::pacs::services::store_result::is_success(), kcenon::pacs::network::dimse::make_c_find_rq(), kcenon::pacs::network::association_config::proposed_contexts, kcenon::pacs::services::storage_scu_config::response_timeout, kcenon::pacs::core::dicom_dataset::set_string(), and kcenon::pacs::services::study_root_find_sop_class_uid.

Here is the call graph for this function: